test/tck/CompletableFutureTest.java

/*
 * Written by Doug Lea and Martin Buchholz with assistance from
 * members of JCP JSR-166 Expert Group and released to the public
 * domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

import junit.framework.*;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import java.util.*;

public class CompletableFutureTest extends JSR166TestCase {

    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    public static Test suite() {
        return new TestSuite(CompletableFutureTest.class);
    }

    void checkIncomplete(CompletableFuture<?> f) {
        assertFalse(f.isDone());
        assertFalse(f.isCancelled());
        assertTrue(f.toString().contains("[Not completed]"));
        try {
            assertNull(f.getNow(null));
        } catch (Throwable fail) { threadUnexpectedException(fail); }
        try {
            f.get(0L, SECONDS);
            shouldThrow();
        }
        catch (TimeoutException success) {}
        catch (Throwable fail) { threadUnexpectedException(fail); }
    }

    void checkCompletedNormally(CompletableFuture<?> f, Object value) {
        assertTrue(f.isDone());
        assertFalse(f.isCancelled());
        assertTrue(f.toString().contains("[Completed normally]"));
        try {
            assertSame(value, f.join());
        } catch (Throwable fail) { threadUnexpectedException(fail); }
        try {
            assertSame(value, f.getNow(null));
        } catch (Throwable fail) { threadUnexpectedException(fail); }
        try {
            assertSame(value, f.get());
        } catch (Throwable fail) { threadUnexpectedException(fail); }
        try {
            assertSame(value, f.get(0L, SECONDS));
        } catch (Throwable fail) { threadUnexpectedException(fail); }
    }

    // XXXX Just a skeleton implementation for now.
    public void testTODO() {
        fail("Please add some real tests!");
    }

    public void testToString() {
        CompletableFuture<String> f;

        f = new CompletableFuture<String>();
        assertTrue(f.toString().contains("[Not completed]"));

        f.complete("foo");
        assertTrue(f.toString().contains("[Completed normally]"));

        f = new CompletableFuture<String>();
        f.completeExceptionally(new IndexOutOfBoundsException());
        assertTrue(f.toString().contains("[Completed exceptionally]"));
    }

    /**
     * allOf(no component futures) returns a future completed normally
     * with the value null
     */
    public void testAllOf_empty() throws Exception {
        CompletableFuture<?> f = CompletableFuture.allOf();
        checkCompletedNormally(f, null);
    }

    /**
     * anyOf(no component futures) returns an incomplete future
     */
    public void testAnyOf_empty() throws Exception {
        CompletableFuture<?> f = CompletableFuture.anyOf();
        checkIncomplete(f);
    }
}
Revision:	1.4
Committed:	Sun Feb 10 21:18:25 2013 UTC (11 years, 3 months ago) by jsr166
Branch:	MAIN
Changes since 1.3:	+53 -4 lines
Log Message:	add testAllOf_empty, testAnyOf_empty
#	User	Rev	Content
1	jsr166	1.1	/*
2	jsr166	1.4	* Written by Doug Lea and Martin Buchholz with assistance from
3			* members of JCP JSR-166 Expert Group and released to the public
4			* domain, as explained at
5	jsr166	1.1	* http://creativecommons.org/publicdomain/zero/1.0/
6			*/
7
8			import junit.framework.*;
9			import java.util.concurrent.Callable;
10			import java.util.concurrent.CancellationException;
11			import java.util.concurrent.CountDownLatch;
12			import java.util.concurrent.ExecutionException;
13			import java.util.concurrent.Future;
14			import java.util.concurrent.CompletableFuture;
15			import java.util.concurrent.TimeoutException;
16			import java.util.concurrent.atomic.AtomicInteger;
17			import static java.util.concurrent.TimeUnit.MILLISECONDS;
18			import static java.util.concurrent.TimeUnit.SECONDS;
19			import java.util.*;
20
21			public class CompletableFutureTest extends JSR166TestCase {
22
23			public static void main(String[] args) {
24			junit.textui.TestRunner.run(suite());
25			}
26			public static Test suite() {
27			return new TestSuite(CompletableFutureTest.class);
28			}
29
30	jsr166	1.4	void checkIncomplete(CompletableFuture<?> f) {
31			assertFalse(f.isDone());
32			assertFalse(f.isCancelled());
33			assertTrue(f.toString().contains("[Not completed]"));
34			try {
35			assertNull(f.getNow(null));
36			} catch (Throwable fail) { threadUnexpectedException(fail); }
37			try {
38			f.get(0L, SECONDS);
39			shouldThrow();
40			}
41			catch (TimeoutException success) {}
42			catch (Throwable fail) { threadUnexpectedException(fail); }
43			}
44
45			void checkCompletedNormally(CompletableFuture<?> f, Object value) {
46			assertTrue(f.isDone());
47			assertFalse(f.isCancelled());
48			assertTrue(f.toString().contains("[Completed normally]"));
49			try {
50			assertSame(value, f.join());
51			} catch (Throwable fail) { threadUnexpectedException(fail); }
52			try {
53			assertSame(value, f.getNow(null));
54			} catch (Throwable fail) { threadUnexpectedException(fail); }
55			try {
56			assertSame(value, f.get());
57			} catch (Throwable fail) { threadUnexpectedException(fail); }
58			try {
59			assertSame(value, f.get(0L, SECONDS));
60			} catch (Throwable fail) { threadUnexpectedException(fail); }
61			}
62
63	jsr166	1.3	// XXXX Just a skeleton implementation for now.
64			public void testTODO() {
65			fail("Please add some real tests!");
66			}
67
68	jsr166	1.1	public void testToString() {
69			CompletableFuture<String> f;
70	jsr166	1.2
71	jsr166	1.1	f = new CompletableFuture<String>();
72	jsr166	1.2	assertTrue(f.toString().contains("[Not completed]"));
73
74	jsr166	1.1	f.complete("foo");
75			assertTrue(f.toString().contains("[Completed normally]"));
76	jsr166	1.2
77	jsr166	1.1	f = new CompletableFuture<String>();
78			f.completeExceptionally(new IndexOutOfBoundsException());
79			assertTrue(f.toString().contains("[Completed exceptionally]"));
80			}
81	jsr166	1.4
82			/**
83			* allOf(no component futures) returns a future completed normally
84			* with the value null
85			*/
86			public void testAllOf_empty() throws Exception {
87			CompletableFuture<?> f = CompletableFuture.allOf();
88			checkCompletedNormally(f, null);
89			}
90
91			/**
92			* anyOf(no component futures) returns an incomplete future
93			*/
94			public void testAnyOf_empty() throws Exception {
95			CompletableFuture<?> f = CompletableFuture.anyOf();
96			checkIncomplete(f);
97			}
98	jsr166	1.1	}