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

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.186 by jsr166, Mon Jul 3 20:55:45 2017 UTC vs.
Revision 1.197 by jsr166, Sun Jul 22 22:08:49 2018 UTC

# Line 41 | Line 41 | import java.util.function.Function;
41   import java.util.function.Predicate;
42   import java.util.function.Supplier;
43  
44 – import junit.framework.AssertionFailedError;
44   import junit.framework.Test;
45   import junit.framework.TestSuite;
46  
# Line 59 | Line 58 | public class CompletableFutureTest exten
58      void checkIncomplete(CompletableFuture<?> f) {
59          assertFalse(f.isDone());
60          assertFalse(f.isCancelled());
61 <        assertTrue(f.toString().contains("Not completed"));
61 >        assertTrue(f.toString().matches(".*\\[.*Not completed.*\\]"));
62 >
63 >        Object result = null;
64          try {
65 <            assertNull(f.getNow(null));
65 >            result = f.getNow(null);
66          } catch (Throwable fail) { threadUnexpectedException(fail); }
67 +        assertNull(result);
68 +
69          try {
70              f.get(randomExpiredTimeout(), randomTimeUnit());
71              shouldThrow();
# Line 71 | Line 74 | public class CompletableFutureTest exten
74          catch (Throwable fail) { threadUnexpectedException(fail); }
75      }
76  
77 <    <T> void checkCompletedNormally(CompletableFuture<T> f, T value) {
78 <        checkTimedGet(f, value);
77 >    <T> void checkCompletedNormally(CompletableFuture<T> f, T expectedValue) {
78 >        checkTimedGet(f, expectedValue);
79  
80 +        assertEquals(expectedValue, f.join());
81 +        assertEquals(expectedValue, f.getNow(null));
82 +
83 +        T result = null;
84          try {
85 <            assertEquals(value, f.join());
79 <            assertEquals(value, f.getNow(null));
80 <            assertEquals(value, f.get());
85 >            result = f.get();
86          } catch (Throwable fail) { threadUnexpectedException(fail); }
87 +        assertEquals(expectedValue, result);
88 +
89          assertTrue(f.isDone());
90          assertFalse(f.isCancelled());
91          assertFalse(f.isCompletedExceptionally());
92 <        assertTrue(f.toString().contains("[Completed normally]"));
92 >        assertTrue(f.toString().matches(".*\\[.*Completed normally.*\\]"));
93      }
94  
95      /**
# Line 138 | Line 145 | public class CompletableFutureTest exten
145          assertFalse(f.isCancelled());
146          assertTrue(f.isDone());
147          assertTrue(f.isCompletedExceptionally());
148 <        assertTrue(f.toString().contains("[Completed exceptionally]"));
148 >        assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
149      }
150  
151      void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
# Line 193 | Line 200 | public class CompletableFutureTest exten
200          assertTrue(f.isDone());
201          assertTrue(f.isCompletedExceptionally());
202          assertTrue(f.isCancelled());
203 <        assertTrue(f.toString().contains("[Completed exceptionally]"));
203 >        assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
204      }
205  
206      /**
# Line 292 | Line 299 | public class CompletableFutureTest exten
299          }
300  
301          f = new CompletableFuture<>();
302 <        f.completeExceptionally(ex = new CFException());
302 >        f.completeExceptionally(new CFException());
303          f.obtrudeValue(v1);
304          checkCompletedNormally(f, v1);
305          f.obtrudeException(ex = new CFException());
# Line 329 | Line 336 | public class CompletableFutureTest exten
336      /**
337       * toString indicates current completion state
338       */
339 <    public void testToString() {
340 <        CompletableFuture<String> f;
341 <
342 <        f = new CompletableFuture<String>();
343 <        assertTrue(f.toString().contains("[Not completed]"));
339 >    public void testToString_incomplete() {
340 >        CompletableFuture<String> f = new CompletableFuture<>();
341 >        assertTrue(f.toString().matches(".*\\[.*Not completed.*\\]"));
342 >        if (testImplementationDetails)
343 >            assertEquals(identityString(f) + "[Not completed]",
344 >                         f.toString());
345 >    }
346  
347 +    public void testToString_normal() {
348 +        CompletableFuture<String> f = new CompletableFuture<>();
349          assertTrue(f.complete("foo"));
350 <        assertTrue(f.toString().contains("[Completed normally]"));
350 >        assertTrue(f.toString().matches(".*\\[.*Completed normally.*\\]"));
351 >        if (testImplementationDetails)
352 >            assertEquals(identityString(f) + "[Completed normally]",
353 >                         f.toString());
354 >    }
355  
356 <        f = new CompletableFuture<String>();
356 >    public void testToString_exception() {
357 >        CompletableFuture<String> f = new CompletableFuture<>();
358          assertTrue(f.completeExceptionally(new IndexOutOfBoundsException()));
359 <        assertTrue(f.toString().contains("[Completed exceptionally]"));
359 >        assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
360 >        if (testImplementationDetails)
361 >            assertTrue(f.toString().startsWith(
362 >                               identityString(f) + "[Completed exceptionally: "));
363 >    }
364  
365 +    public void testToString_cancelled() {
366          for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
367 <            f = new CompletableFuture<String>();
367 >            CompletableFuture<String> f = new CompletableFuture<>();
368              assertTrue(f.cancel(mayInterruptIfRunning));
369 <            assertTrue(f.toString().contains("[Completed exceptionally]"));
369 >            assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
370 >            if (testImplementationDetails)
371 >                assertTrue(f.toString().startsWith(
372 >                                   identityString(f) + "[Completed exceptionally: "));
373          }
374      }
375  
# Line 1238 | Line 1262 | public class CompletableFutureTest exten
1262          r.assertInvoked();
1263      }}
1264  
1265 +    @SuppressWarnings("FutureReturnValueIgnored")
1266      public void testRunAsync_rejectingExecutor() {
1267          CountingRejectingExecutor e = new CountingRejectingExecutor();
1268          try {
# Line 1284 | Line 1309 | public class CompletableFutureTest exten
1309          r.assertInvoked();
1310      }}
1311  
1312 +    @SuppressWarnings("FutureReturnValueIgnored")
1313      public void testSupplyAsync_rejectingExecutor() {
1314          CountingRejectingExecutor e = new CountingRejectingExecutor();
1315          try {
# Line 4171 | Line 4197 | public class CompletableFutureTest exten
4197          static void assertZero(CompletableFuture<?> f) {
4198              try {
4199                  f.getNow(null);
4200 <                throw new AssertionFailedError("should throw");
4200 >                throw new AssertionError("should throw");
4201              } catch (CompletionException success) {
4202                  assertTrue(success.getCause() instanceof ZeroException);
4203              }
# Line 4296 | Line 4322 | public class CompletableFutureTest exten
4322      }
4323  
4324      /** Test long recursive chains of CompletableFutures with cascading completions */
4325 +    @SuppressWarnings("FutureReturnValueIgnored")
4326      public void testRecursiveChains() throws Throwable {
4327          for (ExecutionMode m : ExecutionMode.values())
4328          for (boolean addDeadEnds : new boolean[] { true, false })
# Line 4320 | Line 4347 | public class CompletableFutureTest exten
4347       * A single CompletableFuture with many dependents.
4348       * A demo of scalability - runtime is O(n).
4349       */
4350 +    @SuppressWarnings("FutureReturnValueIgnored")
4351      public void testManyDependents() throws Throwable {
4352          final int n = expensiveTests ? 1_000_000 : 10;
4353          final CompletableFuture<Void> head = new CompletableFuture<>();
# Line 4349 | Line 4377 | public class CompletableFutureTest exten
4377      }
4378  
4379      /** ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest tck */
4380 +    @SuppressWarnings("FutureReturnValueIgnored")
4381      public void testCoCompletionGarbageRetention() throws Throwable {
4382          final int n = expensiveTests ? 1_000_000 : 10;
4383          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
# Line 4367 | Line 4396 | public class CompletableFutureTest exten
4396              f.complete(null);
4397  
4398              f = new CompletableFuture<>();
4399 <            CompletableFuture.anyOf(new CompletableFuture<?>[] { f, incomplete });
4399 >            CompletableFuture.anyOf(f, incomplete);
4400              f.complete(null);
4401          }
4402  
# Line 4385 | Line 4414 | public class CompletableFutureTest exten
4414              f.complete(null);
4415  
4416              f = new CompletableFuture<>();
4417 <            CompletableFuture.anyOf(new CompletableFuture<?>[] { incomplete, f });
4417 >            CompletableFuture.anyOf(incomplete, f);
4418              f.complete(null);
4419          }
4420      }

Diff Legend

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