test/tck/ExecutorCompletionServiceTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes, 
 * Pat Fisher, Mike Judd. 
 */


import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.math.BigInteger;
import java.security.*;

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


    /**
     * Creating a new ECS with null Executor throw NPE
     */ 
    public void testConstructorNPE() {
        try {
            ExecutorCompletionService ecs = new ExecutorCompletionService(null);
            shouldThrow();
        } catch (NullPointerException success) {
        }
    }

    /**
     * Creating a new ECS with null queue throw NPE
     */ 
    public void testConstructorNPE2() {
        try {
            ExecutorService e = Executors.newCachedThreadPool();
            ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
            shouldThrow();
        } catch (NullPointerException success) {
        }
    }

    /**
     * Submitting a null callable throws NPE
     */ 
    public void testSubmitNPE() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Callable c = null;
            ecs.submit(c);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * Submitting a null runnable throws NPE
     */ 
    public void testSubmitNPE2() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Runnable r = null;
            ecs.submit(r, Boolean.TRUE);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * A taken submitted task is completed
     */ 
    public void testTake() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Callable c = new StringTask();
            ecs.submit(c);
            Future f = ecs.take();
            assert(f.isDone());
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * Take returns the same future object returned by submit
     */ 
    public void testTake2() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Callable c = new StringTask();
            Future f1 = ecs.submit(c);
            Future f2 = ecs.take();
            assertSame(f1, f2);
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * If poll returns non-null, the returned task is completed
     */ 
    public void testPoll1() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            assertNull(ecs.poll());
            Callable c = new StringTask();
            ecs.submit(c);
            Thread.sleep(SHORT_DELAY_MS);
            for (;;) {
                Future f = ecs.poll();
                if (f != null) {
                    assert(f.isDone());
                    break;
                }
            }
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * If timed poll returns non-null, the returned task is completed
     */ 
    public void testPoll2() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            assertNull(ecs.poll());
            Callable c = new StringTask();
            ecs.submit(c);
            Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
            if (f != null) 
                assert(f.isDone());
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

}
Revision:	1.2
Committed:	Sat Dec 27 19:26:43 2003 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
CVS Tags:	JSR166_PFD
Changes since 1.1:	+5 -4 lines
Log Message:	Headers reference Creative Commons
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.2	* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4			* http://creativecommons.org/licenses/publicdomain
5			* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
8
9
10			import junit.framework.*;
11			import java.util.*;
12			import java.util.concurrent.*;
13			import java.math.BigInteger;
14			import java.security.*;
15
16			public class ExecutorCompletionServiceTest extends JSR166TestCase{
17			public static void main(String[] args) {
18			junit.textui.TestRunner.run (suite());
19			}
20			public static Test suite() {
21			return new TestSuite(ExecutorCompletionServiceTest.class);
22			}
23
24
25			/**
26			* Creating a new ECS with null Executor throw NPE
27			*/
28			public void testConstructorNPE() {
29			try {
30			ExecutorCompletionService ecs = new ExecutorCompletionService(null);
31			shouldThrow();
32			} catch (NullPointerException success) {
33			}
34			}
35
36			/**
37			* Creating a new ECS with null queue throw NPE
38			*/
39			public void testConstructorNPE2() {
40			try {
41			ExecutorService e = Executors.newCachedThreadPool();
42			ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
43			shouldThrow();
44			} catch (NullPointerException success) {
45			}
46			}
47
48			/**
49			* Submitting a null callable throws NPE
50			*/
51			public void testSubmitNPE() {
52			ExecutorService e = Executors.newCachedThreadPool();
53			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
54			try {
55			Callable c = null;
56			ecs.submit(c);
57			shouldThrow();
58			} catch (NullPointerException success) {
59			} finally {
60			joinPool(e);
61			}
62			}
63
64			/**
65			* Submitting a null runnable throws NPE
66			*/
67			public void testSubmitNPE2() {
68			ExecutorService e = Executors.newCachedThreadPool();
69			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
70			try {
71			Runnable r = null;
72			ecs.submit(r, Boolean.TRUE);
73			shouldThrow();
74			} catch (NullPointerException success) {
75			} finally {
76			joinPool(e);
77			}
78			}
79
80			/**
81			* A taken submitted task is completed
82			*/
83			public void testTake() {
84			ExecutorService e = Executors.newCachedThreadPool();
85			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
86			try {
87			Callable c = new StringTask();
88			ecs.submit(c);
89			Future f = ecs.take();
90			assert(f.isDone());
91			} catch (Exception ex) {
92			unexpectedException();
93			} finally {
94			joinPool(e);
95			}
96			}
97
98			/**
99			* Take returns the same future object returned by submit
100			*/
101			public void testTake2() {
102			ExecutorService e = Executors.newCachedThreadPool();
103			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
104			try {
105			Callable c = new StringTask();
106			Future f1 = ecs.submit(c);
107			Future f2 = ecs.take();
108			assertSame(f1, f2);
109			} catch (Exception ex) {
110			unexpectedException();
111			} finally {
112			joinPool(e);
113			}
114			}
115
116			/**
117			* If poll returns non-null, the returned task is completed
118			*/
119			public void testPoll1() {
120			ExecutorService e = Executors.newCachedThreadPool();
121			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
122			try {
123			assertNull(ecs.poll());
124			Callable c = new StringTask();
125			ecs.submit(c);
126			Thread.sleep(SHORT_DELAY_MS);
127			for (;;) {
128			Future f = ecs.poll();
129			if (f != null) {
130			assert(f.isDone());
131			break;
132			}
133			}
134			} catch (Exception ex) {
135			unexpectedException();
136			} finally {
137			joinPool(e);
138			}
139			}
140
141			/**
142			* If timed poll returns non-null, the returned task is completed
143			*/
144			public void testPoll2() {
145			ExecutorService e = Executors.newCachedThreadPool();
146			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
147			try {
148			assertNull(ecs.poll());
149			Callable c = new StringTask();
150			ecs.submit(c);
151			Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
152			if (f != null)
153			assert(f.isDone());
154			} catch (Exception ex) {
155			unexpectedException();
156			} finally {
157			joinPool(e);
158			}
159			}
160
161			}