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

Comparing jsr166/src/test/tck/CountedCompleterTest.java (file contents):
Revision 1.12 by jsr166, Sun Jul 14 21:43:56 2013 UTC vs.
Revision 1.27 by jsr166, Sun Oct 18 19:33:21 2015 UTC

# Line 3 | Line 3
3   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6 < import java.util.concurrent.ExecutionException;
6 >
7 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
8 > import static java.util.concurrent.TimeUnit.SECONDS;
9 >
10 > import java.util.HashSet;
11   import java.util.concurrent.CancellationException;
12 + import java.util.concurrent.CountedCompleter;
13 + import java.util.concurrent.ExecutionException;
14   import java.util.concurrent.ForkJoinPool;
15   import java.util.concurrent.ForkJoinTask;
10 – import java.util.concurrent.CountedCompleter;
11 – import java.util.concurrent.ForkJoinWorkerThread;
12 – import java.util.concurrent.RecursiveAction;
13 – import java.util.concurrent.TimeUnit;
16   import java.util.concurrent.TimeoutException;
17   import java.util.concurrent.atomic.AtomicInteger;
16 – import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
18   import java.util.concurrent.atomic.AtomicReference;
19 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
20 < import static java.util.concurrent.TimeUnit.SECONDS;
21 < import java.util.HashSet;
21 < import junit.framework.*;
19 >
20 > import junit.framework.Test;
21 > import junit.framework.TestSuite;
22  
23   public class CountedCompleterTest extends JSR166TestCase {
24  
25      public static void main(String[] args) {
26 <        junit.textui.TestRunner.run(suite());
26 >        main(suite(), args);
27      }
28  
29      public static Test suite() {
# Line 49 | Line 49 | public class CountedCompleterTest extend
49      }
50  
51      private void testInvokeOnPool(ForkJoinPool pool, ForkJoinTask a) {
52 <        try {
52 >        try (PoolCleaner cleaner = cleaner(pool)) {
53              assertFalse(a.isDone());
54              assertFalse(a.isCompletedNormally());
55              assertFalse(a.isCompletedAbnormally());
# Line 65 | Line 65 | public class CountedCompleterTest extend
65              assertFalse(a.isCancelled());
66              assertNull(a.getException());
67              assertNull(a.getRawResult());
68 –        } finally {
69 –            joinPool(pool);
68          }
69      }
70  
# Line 95 | Line 93 | public class CountedCompleterTest extend
93  
94          {
95              Thread.currentThread().interrupt();
96 <            long t0 = System.nanoTime();
96 >            long startTime = System.nanoTime();
97              assertNull(a.join());
98 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
98 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
99              Thread.interrupted();
100          }
101  
102          {
103              Thread.currentThread().interrupt();
104 <            long t0 = System.nanoTime();
104 >            long startTime = System.nanoTime();
105              a.quietlyJoin();        // should be no-op
106 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
106 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
107              Thread.interrupted();
108          }
109  
# Line 138 | Line 136 | public class CountedCompleterTest extend
136          Thread.interrupted();
137  
138          {
139 <            long t0 = System.nanoTime();
139 >            long startTime = System.nanoTime();
140              a.quietlyJoin();        // should be no-op
141 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
141 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
142          }
143  
144          try {
# Line 176 | Line 174 | public class CountedCompleterTest extend
174          Thread.interrupted();
175  
176          {
177 <            long t0 = System.nanoTime();
177 >            long startTime = System.nanoTime();
178              a.quietlyJoin();        // should be no-op
179 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
179 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
180          }
181  
182          try {
# Line 198 | Line 196 | public class CountedCompleterTest extend
196          try {
197              a.invoke();
198              shouldThrow();
199 <        } catch (Throwable ex) {
200 <            assertSame(t, ex);
199 >        } catch (Throwable success) {
200 >            assertSame(t, success);
201          }
202      }
203  
# Line 280 | Line 278 | public class CountedCompleterTest extend
278      final class NoopCC extends CheckedCC {
279          NoopCC() { super(); }
280          NoopCC(CountedCompleter p) { super(p); }
281 +        NoopCC(CountedCompleter p, int initialPendingCount) {
282 +            super(p, initialPendingCount);
283 +        }
284          protected void realCompute() {}
285      }
286  
# Line 298 | Line 299 | public class CountedCompleterTest extend
299      void testComplete(NoopCC cc, Object x, int pendingCount) {
300          cc.setPendingCount(pendingCount);
301          cc.checkCompletes(x);
302 +        assertEquals(pendingCount, cc.getPendingCount());
303      }
304  
305      /**
# Line 311 | Line 313 | public class CountedCompleterTest extend
313      }
314  
315      /**
316 <     * completeExceptionally(null) throws NullPointerException
316 >     * completeExceptionally(null) surprisingly has the same effect as
317 >     * completeExceptionally(new RuntimeException())
318       */
319      public void testCompleteExceptionally_null() {
320 +        NoopCC a = new NoopCC();
321 +        a.completeExceptionally(null);
322          try {
323 <            new NoopCC()
319 <                .checkCompletesExceptionally(null);
323 >            a.invoke();
324              shouldThrow();
325 <        } catch (NullPointerException success) {}
325 >        } catch (RuntimeException success) {
326 >            assertSame(success.getClass(), RuntimeException.class);
327 >            assertNull(success.getCause());
328 >            a.checkCompletedExceptionally(success);
329 >        }
330      }
331  
332      /**
# Line 327 | Line 335 | public class CountedCompleterTest extend
335      public void testSetPendingCount() {
336          NoopCC a = new NoopCC();
337          assertEquals(0, a.getPendingCount());
338 <        a.setPendingCount(1);
339 <        assertEquals(1, a.getPendingCount());
340 <        a.setPendingCount(27);
341 <        assertEquals(27, a.getPendingCount());
338 >        int[] vals = {
339 >             -1, 0, 1,
340 >             Integer.MIN_VALUE,
341 >             Integer.MAX_VALUE,
342 >        };
343 >        for (int val : vals) {
344 >            a.setPendingCount(val);
345 >            assertEquals(val, a.getPendingCount());
346 >        }
347      }
348  
349      /**
# Line 343 | Line 356 | public class CountedCompleterTest extend
356          assertEquals(1, a.getPendingCount());
357          a.addToPendingCount(27);
358          assertEquals(28, a.getPendingCount());
359 +        a.addToPendingCount(-28);
360 +        assertEquals(0, a.getPendingCount());
361      }
362  
363      /**
364       * decrementPendingCountUnlessZero decrements reported pending
365       * count unless zero
366       */
367 <    public void testDecrementPendingCount() {
368 <        NoopCC a = new NoopCC();
369 <        assertEquals(0, a.getPendingCount());
370 <        a.addToPendingCount(1);
367 >    public void testDecrementPendingCountUnlessZero() {
368 >        NoopCC a = new NoopCC(null, 2);
369 >        assertEquals(2, a.getPendingCount());
370 >        assertEquals(2, a.decrementPendingCountUnlessZero());
371          assertEquals(1, a.getPendingCount());
372 <        a.decrementPendingCountUnlessZero();
372 >        assertEquals(1, a.decrementPendingCountUnlessZero());
373          assertEquals(0, a.getPendingCount());
374 <        a.decrementPendingCountUnlessZero();
374 >        assertEquals(0, a.decrementPendingCountUnlessZero());
375          assertEquals(0, a.getPendingCount());
376 +        a.setPendingCount(-1);
377 +        assertEquals(-1, a.decrementPendingCountUnlessZero());
378 +        assertEquals(-2, a.getPendingCount());
379      }
380  
381      /**
# Line 481 | Line 499 | public class CountedCompleterTest extend
499      }
500  
501      /**
502 <     * quietlyCompleteRoot completes root task
502 >     * quietlyCompleteRoot completes root task and only root task
503       */
504      public void testQuietlyCompleteRoot() {
505          NoopCC a = new NoopCC();
# Line 1137 | Line 1155 | public class CountedCompleterTest extend
1155      }
1156  
1157      /**
1158 <     * invokeAll(collection)  throws exception if any task does
1158 >     * invokeAll(collection) throws exception if any task does
1159       */
1160      public void testAbnormalInvokeAllCollection() {
1161          ForkJoinTask a = new CheckedRecursiveAction() {
# Line 1802 | Line 1820 | public class CountedCompleterTest extend
1820      }
1821  
1822      /**
1823 <     * invokeAll(collection)  throws exception if any task does
1823 >     * invokeAll(collection) throws exception if any task does
1824       */
1825      public void testAbnormalInvokeAllCollectionSingleton() {
1826          ForkJoinTask a = new CheckedRecursiveAction() {

Diff Legend

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