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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8