test/tck/ExecutorCompletionServiceTest.java

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