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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8