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.24 by jsr166, Sat May 21 22:30:16 2016 UTC vs.
Revision 1.30 by dl, Tue Jan 26 13:33:06 2021 UTC

# Line 14 | Line 14 | import java.util.concurrent.CompletionSe
14   import java.util.concurrent.CountDownLatch;
15   import java.util.concurrent.ExecutionException;
16   import java.util.concurrent.ExecutorCompletionService;
17 – import java.util.concurrent.Executor;
18 – import java.util.concurrent.Executors;
17   import java.util.concurrent.ExecutorService;
20 – import java.util.concurrent.ForkJoinPool;
18   import java.util.concurrent.Future;
19   import java.util.concurrent.FutureTask;
20   import java.util.concurrent.RunnableFuture;
# Line 41 | Line 38 | public class ExecutorCompletionServiceTe
38       */
39      public void testConstructorNPE() {
40          try {
41 <            new ExecutorCompletionService(null);
41 >            new ExecutorCompletionService<Item>(null);
42              shouldThrow();
43          } catch (NullPointerException success) {}
44      }
# Line 50 | Line 47 | public class ExecutorCompletionServiceTe
47       * new ExecutorCompletionService(e, null) throws NullPointerException
48       */
49      public void testConstructorNPE2() {
53 –        final Executor e = ForkJoinPool.commonPool();
50          try {
51 <            new ExecutorCompletionService(e, null);
51 >            new ExecutorCompletionService<Item>(cachedThreadPool, null);
52              shouldThrow();
53          } catch (NullPointerException success) {}
54      }
# Line 61 | Line 57 | public class ExecutorCompletionServiceTe
57       * ecs.submit(null) throws NullPointerException
58       */
59      public void testSubmitNullCallable() {
60 <        final ExecutorCompletionService ecs =
65 <            new ExecutorCompletionService(ForkJoinPool.commonPool());
60 >        CompletionService<Item> cs = new ExecutorCompletionService<Item>(cachedThreadPool);
61          try {
62 <            ecs.submit((Callable) null);
62 >            cs.submit((Callable<Item>) null);
63              shouldThrow();
64          } catch (NullPointerException success) {}
65      }
# Line 73 | Line 68 | public class ExecutorCompletionServiceTe
68       * ecs.submit(null, val) throws NullPointerException
69       */
70      public void testSubmitNullRunnable() {
71 <        final ExecutorCompletionService ecs =
77 <            new ExecutorCompletionService(ForkJoinPool.commonPool());
71 >        CompletionService<Boolean> cs = new ExecutorCompletionService<Boolean>(cachedThreadPool);
72          try {
73 <            ecs.submit((Runnable) null, Boolean.TRUE);
73 >            cs.submit((Runnable) null, Boolean.TRUE);
74              shouldThrow();
75          } catch (NullPointerException success) {}
76      }
# Line 84 | Line 78 | public class ExecutorCompletionServiceTe
78      /**
79       * A taken submitted task is completed
80       */
81 <    public void testTake()
82 <        throws InterruptedException, ExecutionException {
83 <        final ExecutorCompletionService ecs =
84 <            new ExecutorCompletionService(ForkJoinPool.commonPool());
91 <        ecs.submit(new StringTask());
92 <        Future f = ecs.take();
81 >    public void testTake() throws Exception {
82 >        CompletionService<String> cs = new ExecutorCompletionService<String>(cachedThreadPool);
83 >        cs.submit(new StringTask());
84 >        Future<?> f = cs.take();
85          assertTrue(f.isDone());
86          assertSame(TEST_STRING, f.get());
87      }
# Line 98 | Line 90 | public class ExecutorCompletionServiceTe
90       * Take returns the same future object returned by submit
91       */
92      public void testTake2() throws InterruptedException {
93 <        final ExecutorCompletionService ecs =
94 <            new ExecutorCompletionService(ForkJoinPool.commonPool());
95 <        Future f1 = ecs.submit(new StringTask());
104 <        Future f2 = ecs.take();
93 >        CompletionService<String> cs = new ExecutorCompletionService<String>(cachedThreadPool);
94 >        Future<?> f1 = cs.submit(new StringTask());
95 >        Future<?> f2 = cs.take();
96          assertSame(f1, f2);
97      }
98  
99      /**
100       * poll returns non-null when the returned task is completed
101       */
102 <    public void testPoll1()
103 <        throws InterruptedException, ExecutionException {
104 <        final ExecutorCompletionService ecs =
105 <            new ExecutorCompletionService(ForkJoinPool.commonPool());
115 <        assertNull(ecs.poll());
116 <        ecs.submit(new StringTask());
102 >    public void testPoll1() throws Exception {
103 >        CompletionService<String> cs = new ExecutorCompletionService<String>(cachedThreadPool);
104 >        assertNull(cs.poll());
105 >        cs.submit(new StringTask());
106  
107          long startTime = System.nanoTime();
108 <        Future f;
109 <        while ((f = ecs.poll()) == null) {
108 >        Future<?> f;
109 >        while ((f = cs.poll()) == null) {
110              if (millisElapsedSince(startTime) > LONG_DELAY_MS)
111                  fail("timed out");
112              Thread.yield();
# Line 129 | Line 118 | public class ExecutorCompletionServiceTe
118      /**
119       * timed poll returns non-null when the returned task is completed
120       */
121 <    public void testPoll2()
122 <        throws InterruptedException, ExecutionException {
123 <        final ExecutorCompletionService ecs =
124 <            new ExecutorCompletionService(ForkJoinPool.commonPool());
136 <        assertNull(ecs.poll());
137 <        ecs.submit(new StringTask());
121 >    public void testPoll2() throws Exception {
122 >        CompletionService<String> cs = new ExecutorCompletionService<String>(cachedThreadPool);
123 >        assertNull(cs.poll());
124 >        cs.submit(new StringTask());
125  
126          long startTime = System.nanoTime();
127 <        Future f;
128 <        while ((f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS)) == null) {
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();
# Line 150 | Line 138 | public class ExecutorCompletionServiceTe
138      /**
139       * poll returns null before the returned task is completed
140       */
141 <    public void testPollReturnsNull()
142 <        throws InterruptedException, ExecutionException {
155 <        final ExecutorCompletionService ecs =
156 <            new ExecutorCompletionService(ForkJoinPool.commonPool());
141 >    public void testPollReturnsNullBeforeCompletion() throws Exception {
142 >        CompletionService<String> cs = new ExecutorCompletionService<String>(cachedThreadPool);
143          final CountDownLatch proceed = new CountDownLatch(1);
144 <        ecs.submit(new Callable() { public String call() throws Exception {
145 <            proceed.await();
144 >        cs.submit(new Callable<String>() { public String call() throws Exception {
145 >            await(proceed);
146              return TEST_STRING;
147          }});
148 <        assertNull(ecs.poll());
149 <        assertNull(ecs.poll(0L, MILLISECONDS));
150 <        assertNull(ecs.poll(Long.MIN_VALUE, MILLISECONDS));
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(ecs.poll(timeoutMillis(), MILLISECONDS));
152 >        assertNull(cs.poll(timeoutMillis(), MILLISECONDS));
153          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
154          proceed.countDown();
155 <        assertSame(TEST_STRING, ecs.take().get());
155 >        assertSame(TEST_STRING, cs.take().get());
156      }
157  
158      /**
159       * successful and failed tasks are both returned
160       */
161 <    public void testTaskAssortment()
162 <        throws InterruptedException, ExecutionException {
163 <        final ExecutorService e = Executors.newCachedThreadPool();
164 <        final CompletionService cs = new ExecutorCompletionService(e);
165 <        final ArithmeticException ex = new ArithmeticException();
166 <        try (PoolCleaner cleaner = cleaner(e)) {
167 <            for (int i = 0; i < 2; i++) {
168 <                cs.submit(new StringTask());
169 <                cs.submit(callableThrowing(ex));
170 <                cs.submit(runnableThrowing(ex), null);
171 <            }
172 <            int normalCompletions = 0;
173 <            int exceptionalCompletions = 0;
174 <            for (int i = 0; i < 3 * 2; i++) {
175 <                try {
176 <                    if (cs.take().get() == TEST_STRING)
177 <                        normalCompletions++;
178 <                }
193 <                catch (ExecutionException expected) {
194 <                    assertTrue(expected.getCause() instanceof ArithmeticException);
195 <                    exceptionalCompletions++;
196 <                }
161 >    public void testTaskAssortment() throws Exception {
162 >        CompletionService<String> cs = new ExecutorCompletionService<String>(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              }
198 –            assertEquals(2 * 1, normalCompletions);
199 –            assertEquals(2 * 2, exceptionalCompletions);
200 –            assertNull(cs.poll());
180          }
181 +        assertEquals(1 * rounds, normalCompletions);
182 +        assertEquals(2 * rounds, exceptionalCompletions);
183 +        assertNull(cs.poll());
184      }
185  
186      /**
# Line 222 | Line 204 | public class ExecutorCompletionServiceTe
204          try (PoolCleaner cleaner = cleaner(e)) {
205              assertNull(cs.poll());
206              Callable<String> c = new StringTask();
207 <            Future f1 = cs.submit(c);
207 >            Future<?> f1 = cs.submit(c);
208              assertTrue("submit must return MyCallableFuture",
209                         f1 instanceof MyCallableFuture);
210 <            Future f2 = cs.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 252 | Line 234 | public class ExecutorCompletionServiceTe
234          try (PoolCleaner cleaner = cleaner(e)) {
235              assertNull(cs.poll());
236              Runnable r = new NoOpRunnable();
237 <            Future f1 = cs.submit(r, null);
237 >            Future<?> f1 = cs.submit(r, null);
238              assertTrue("submit must return MyRunnableFuture",
239                         f1 instanceof MyRunnableFuture);
240 <            Future f2 = cs.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