[cvs] / jsr166 / src / test / tck / BlockingQueueTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/BlockingQueueTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.8 - (view) (download)

1 : jsr166 1.1 /*
2 :     * Written by Doug Lea and Martin Buchholz with assistance from members
3 :     * of JCP JSR-166 Expert Group and released to the public domain, as
4 : jsr166 1.5 * explained at http://creativecommons.org/publicdomain/zero/1.0/
5 : jsr166 1.1 *
6 :     * Other contributors include Andrew Wright, Jeffrey Hayes,
7 :     * Pat Fisher, Mike Judd.
8 :     */
9 :    
10 :     import junit.framework.*;
11 : jsr166 1.8 import java.util.Arrays;
12 :     import java.util.Collection;
13 :     import java.util.Queue;
14 :     import java.util.concurrent.BlockingQueue;
15 :     import java.util.concurrent.CountDownLatch;
16 : jsr166 1.1 import static java.util.concurrent.TimeUnit.MILLISECONDS;
17 :    
18 :     /**
19 : jsr166 1.8 * Contains "contract" tests applicable to all BlockingQueue implementations.
20 : jsr166 1.1 */
21 :     public abstract class BlockingQueueTest extends JSR166TestCase {
22 :     /*
23 :     * This is the start of an attempt to refactor the tests for the
24 :     * various related implementations of related interfaces without
25 :     * too much duplicated code. junit does not really support such
26 :     * testing. Here subclasses of TestCase not only contain tests,
27 :     * but also configuration information that describes the
28 :     * implementation class, most importantly how to instantiate
29 :     * instances.
30 :     */
31 :    
32 :     /** Like suite(), but non-static */
33 :     public Test testSuite() {
34 :     // TODO: filter the returned tests using the configuration
35 :     // information provided by the subclass via protected methods.
36 :     return new TestSuite(this.getClass());
37 :     }
38 :    
39 : jsr166 1.8 //----------------------------------------------------------------
40 :     // Configuration methods
41 :     //----------------------------------------------------------------
42 :    
43 : jsr166 1.1 /** Returns an empty instance of the implementation class. */
44 :     protected abstract BlockingQueue emptyCollection();
45 :    
46 :     /**
47 : jsr166 1.8 * Returns an element suitable for insertion in the collection.
48 :     * Override for collections with unusual element types.
49 :     */
50 :     protected Object makeElement(int i) {
51 :     return Integer.valueOf(i);
52 :     }
53 :    
54 :     //----------------------------------------------------------------
55 :     // Tests
56 :     //----------------------------------------------------------------
57 :    
58 :     /**
59 :     * offer(null) throws NullPointerException
60 :     */
61 :     public void testOfferNull() {
62 :     final Queue q = emptyCollection();
63 :     try {
64 :     q.offer(null);
65 :     shouldThrow();
66 :     } catch (NullPointerException success) {}
67 :     }
68 :    
69 :     /**
70 :     * add(null) throws NullPointerException
71 :     */
72 :     public void testAddNull() {
73 :     final Collection q = emptyCollection();
74 :     try {
75 :     q.add(null);
76 :     shouldThrow();
77 :     } catch (NullPointerException success) {}
78 :     }
79 :    
80 :     /**
81 :     * timed offer(null) throws NullPointerException
82 :     */
83 :     public void testTimedOfferNull() throws InterruptedException {
84 :     final BlockingQueue q = emptyCollection();
85 :     long startTime = System.nanoTime();
86 :     try {
87 :     q.offer(null, LONG_DELAY_MS, MILLISECONDS);
88 :     shouldThrow();
89 :     } catch (NullPointerException success) {}
90 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
91 :     }
92 :    
93 :     /**
94 :     * put(null) throws NullPointerException
95 :     */
96 :     public void testPutNull() throws InterruptedException {
97 :     final BlockingQueue q = emptyCollection();
98 :     try {
99 :     q.put(null);
100 :     shouldThrow();
101 :     } catch (NullPointerException success) {}
102 :     }
103 :    
104 :     /**
105 :     * put(null) throws NullPointerException
106 :     */
107 :     public void testAddAllNull() throws InterruptedException {
108 :     final Collection q = emptyCollection();
109 :     try {
110 :     q.addAll(null);
111 :     shouldThrow();
112 :     } catch (NullPointerException success) {}
113 :     }
114 :    
115 :     /**
116 :     * addAll of a collection with null elements throws NullPointerException
117 :     */
118 :     public void testAddAllNullElements() {
119 :     final Collection q = emptyCollection();
120 :     final Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
121 :     try {
122 :     q.addAll(elements);
123 :     shouldThrow();
124 :     } catch (NullPointerException success) {}
125 :     }
126 :    
127 :     /**
128 :     * toArray(null) throws NullPointerException
129 :     */
130 :     public void testToArray_NullArray() {
131 :     final Collection q = emptyCollection();
132 :     try {
133 :     q.toArray(null);
134 :     shouldThrow();
135 :     } catch (NullPointerException success) {}
136 :     }
137 :    
138 :     /**
139 :     * drainTo(null) throws NullPointerException
140 :     */
141 :     public void testDrainToNull() {
142 :     final BlockingQueue q = emptyCollection();
143 :     try {
144 :     q.drainTo(null);
145 :     shouldThrow();
146 :     } catch (NullPointerException success) {}
147 :     }
148 :    
149 :     /**
150 :     * drainTo(this) throws IllegalArgumentException
151 :     */
152 :     public void testDrainToSelf() {
153 :     final BlockingQueue q = emptyCollection();
154 :     try {
155 :     q.drainTo(q);
156 :     shouldThrow();
157 :     } catch (IllegalArgumentException success) {}
158 :     }
159 :    
160 :     /**
161 :     * drainTo(null, n) throws NullPointerException
162 :     */
163 :     public void testDrainToNullN() {
164 :     final BlockingQueue q = emptyCollection();
165 :     try {
166 :     q.drainTo(null, 0);
167 :     shouldThrow();
168 :     } catch (NullPointerException success) {}
169 :     }
170 :    
171 :     /**
172 :     * drainTo(this, n) throws IllegalArgumentException
173 :     */
174 :     public void testDrainToSelfN() {
175 :     final BlockingQueue q = emptyCollection();
176 :     try {
177 :     q.drainTo(q, 0);
178 :     shouldThrow();
179 :     } catch (IllegalArgumentException success) {}
180 :     }
181 :    
182 :     /**
183 : jsr166 1.7 * timed poll before a delayed offer times out; after offer succeeds;
184 : jsr166 1.1 * on interruption throws
185 :     */
186 :     public void testTimedPollWithOffer() throws InterruptedException {
187 :     final BlockingQueue q = emptyCollection();
188 :     final CheckedBarrier barrier = new CheckedBarrier(2);
189 : jsr166 1.8 final Object zero = makeElement(0);
190 : jsr166 1.1 Thread t = newStartedThread(new CheckedRunnable() {
191 :     public void realRun() throws InterruptedException {
192 : jsr166 1.7 long startTime = System.nanoTime();
193 :     assertNull(q.poll(timeoutMillis(), MILLISECONDS));
194 :     assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
195 : jsr166 1.1
196 :     barrier.await();
197 : jsr166 1.7
198 :     assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
199 : jsr166 1.1
200 :     Thread.currentThread().interrupt();
201 :     try {
202 : jsr166 1.7 q.poll(LONG_DELAY_MS, MILLISECONDS);
203 : jsr166 1.1 shouldThrow();
204 :     } catch (InterruptedException success) {}
205 : jsr166 1.7 assertFalse(Thread.interrupted());
206 : jsr166 1.1
207 :     barrier.await();
208 :     try {
209 : jsr166 1.7 q.poll(LONG_DELAY_MS, MILLISECONDS);
210 : jsr166 1.1 shouldThrow();
211 :     } catch (InterruptedException success) {}
212 : jsr166 1.7 assertFalse(Thread.interrupted());
213 : jsr166 1.1 }});
214 :    
215 :     barrier.await();
216 : jsr166 1.7 long startTime = System.nanoTime();
217 :     assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
218 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
219 :    
220 : jsr166 1.1 barrier.await();
221 : jsr166 1.7 assertThreadStaysAlive(t);
222 : jsr166 1.1 t.interrupt();
223 : jsr166 1.7 awaitTermination(t);
224 : jsr166 1.1 }
225 :    
226 : jsr166 1.2 /**
227 : jsr166 1.3 * take() blocks interruptibly when empty
228 : jsr166 1.2 */
229 : jsr166 1.7 public void testTakeFromEmptyBlocksInterruptibly() {
230 : jsr166 1.2 final BlockingQueue q = emptyCollection();
231 :     final CountDownLatch threadStarted = new CountDownLatch(1);
232 :     Thread t = newStartedThread(new CheckedRunnable() {
233 :     public void realRun() {
234 :     threadStarted.countDown();
235 :     try {
236 :     q.take();
237 :     shouldThrow();
238 :     } catch (InterruptedException success) {}
239 : jsr166 1.7 assertFalse(Thread.interrupted());
240 : jsr166 1.2 }});
241 : jsr166 1.3
242 : jsr166 1.7 await(threadStarted);
243 :     assertThreadStaysAlive(t);
244 : jsr166 1.2 t.interrupt();
245 : jsr166 1.7 awaitTermination(t);
246 : jsr166 1.3 }
247 :    
248 :     /**
249 :     * take() throws InterruptedException immediately if interrupted
250 :     * before waiting
251 :     */
252 : jsr166 1.7 public void testTakeFromEmptyAfterInterrupt() {
253 : jsr166 1.3 final BlockingQueue q = emptyCollection();
254 :     Thread t = newStartedThread(new CheckedRunnable() {
255 :     public void realRun() {
256 :     Thread.currentThread().interrupt();
257 :     try {
258 :     q.take();
259 :     shouldThrow();
260 :     } catch (InterruptedException success) {}
261 : jsr166 1.7 assertFalse(Thread.interrupted());
262 :     }});
263 :    
264 :     awaitTermination(t);
265 :     }
266 :    
267 :     /**
268 :     * timed poll() blocks interruptibly when empty
269 :     */
270 :     public void testTimedPollFromEmptyBlocksInterruptibly() {
271 :     final BlockingQueue q = emptyCollection();
272 :     final CountDownLatch threadStarted = new CountDownLatch(1);
273 :     Thread t = newStartedThread(new CheckedRunnable() {
274 :     public void realRun() {
275 :     threadStarted.countDown();
276 :     try {
277 :     q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
278 :     shouldThrow();
279 :     } catch (InterruptedException success) {}
280 :     assertFalse(Thread.interrupted());
281 :     }});
282 :    
283 :     await(threadStarted);
284 :     assertThreadStaysAlive(t);
285 :     t.interrupt();
286 :     awaitTermination(t);
287 :     }
288 :    
289 :     /**
290 :     * timed poll() throws InterruptedException immediately if
291 :     * interrupted before waiting
292 :     */
293 :     public void testTimedPollFromEmptyAfterInterrupt() {
294 :     final BlockingQueue q = emptyCollection();
295 :     Thread t = newStartedThread(new CheckedRunnable() {
296 :     public void realRun() {
297 :     Thread.currentThread().interrupt();
298 :     try {
299 :     q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
300 :     shouldThrow();
301 :     } catch (InterruptedException success) {}
302 :     assertFalse(Thread.interrupted());
303 : jsr166 1.3 }});
304 :    
305 : jsr166 1.7 awaitTermination(t);
306 : jsr166 1.2 }
307 :    
308 : jsr166 1.1 /** For debugging. */
309 :     public void XXXXtestFails() {
310 :     fail(emptyCollection().getClass().toString());
311 :     }
312 :    
313 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8