[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.19 - (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 :     * put(null) throws NullPointerException
110 :     */
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 :     for (int n : ns)
193 :     assertEquals(0, q.drainTo(new ArrayList(), n));
194 :     if (q.remainingCapacity() > 0) {
195 :     // Not SynchronousQueue, that is
196 : jsr166 1.10 Object one = makeElement(1);
197 :     q.add(one);
198 :     ArrayList c = new ArrayList();
199 : jsr166 1.11 for (int n : ns)
200 :     assertEquals(0, q.drainTo(new ArrayList(), n));
201 : jsr166 1.10 assertEquals(1, q.size());
202 :     assertSame(one, q.poll());
203 :     assertTrue(c.isEmpty());
204 :     }
205 :     }
206 :    
207 :     /**
208 : jsr166 1.7 * timed poll before a delayed offer times out; after offer succeeds;
209 : jsr166 1.1 * on interruption throws
210 :     */
211 :     public void testTimedPollWithOffer() throws InterruptedException {
212 :     final BlockingQueue q = emptyCollection();
213 :     final CheckedBarrier barrier = new CheckedBarrier(2);
214 : jsr166 1.8 final Object zero = makeElement(0);
215 : jsr166 1.1 Thread t = newStartedThread(new CheckedRunnable() {
216 :     public void realRun() throws InterruptedException {
217 : jsr166 1.7 long startTime = System.nanoTime();
218 :     assertNull(q.poll(timeoutMillis(), MILLISECONDS));
219 :     assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
220 : jsr166 1.1
221 :     barrier.await();
222 : jsr166 1.7
223 :     assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
224 : jsr166 1.1
225 :     Thread.currentThread().interrupt();
226 :     try {
227 : jsr166 1.7 q.poll(LONG_DELAY_MS, MILLISECONDS);
228 : jsr166 1.1 shouldThrow();
229 :     } catch (InterruptedException success) {}
230 : jsr166 1.7 assertFalse(Thread.interrupted());
231 : jsr166 1.1
232 :     barrier.await();
233 :     try {
234 : jsr166 1.7 q.poll(LONG_DELAY_MS, MILLISECONDS);
235 : jsr166 1.1 shouldThrow();
236 :     } catch (InterruptedException success) {}
237 : jsr166 1.7 assertFalse(Thread.interrupted());
238 : jsr166 1.17
239 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
240 : jsr166 1.1 }});
241 :    
242 :     barrier.await();
243 : jsr166 1.7 long startTime = System.nanoTime();
244 :     assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
245 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
246 :    
247 : jsr166 1.1 barrier.await();
248 : jsr166 1.19 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
249 : jsr166 1.1 t.interrupt();
250 : jsr166 1.7 awaitTermination(t);
251 : jsr166 1.1 }
252 :    
253 : jsr166 1.2 /**
254 : jsr166 1.3 * take() blocks interruptibly when empty
255 : jsr166 1.2 */
256 : jsr166 1.7 public void testTakeFromEmptyBlocksInterruptibly() {
257 : jsr166 1.2 final BlockingQueue q = emptyCollection();
258 :     final CountDownLatch threadStarted = new CountDownLatch(1);
259 :     Thread t = newStartedThread(new CheckedRunnable() {
260 :     public void realRun() {
261 :     threadStarted.countDown();
262 :     try {
263 :     q.take();
264 :     shouldThrow();
265 :     } catch (InterruptedException success) {}
266 : jsr166 1.7 assertFalse(Thread.interrupted());
267 : jsr166 1.2 }});
268 : jsr166 1.3
269 : jsr166 1.7 await(threadStarted);
270 : jsr166 1.18 assertThreadBlocks(t, Thread.State.WAITING);
271 : jsr166 1.2 t.interrupt();
272 : jsr166 1.7 awaitTermination(t);
273 : jsr166 1.3 }
274 :    
275 :     /**
276 :     * take() throws InterruptedException immediately if interrupted
277 :     * before waiting
278 :     */
279 : jsr166 1.7 public void testTakeFromEmptyAfterInterrupt() {
280 : jsr166 1.3 final BlockingQueue q = emptyCollection();
281 :     Thread t = newStartedThread(new CheckedRunnable() {
282 :     public void realRun() {
283 :     Thread.currentThread().interrupt();
284 :     try {
285 :     q.take();
286 :     shouldThrow();
287 :     } catch (InterruptedException success) {}
288 : jsr166 1.7 assertFalse(Thread.interrupted());
289 :     }});
290 :    
291 :     awaitTermination(t);
292 :     }
293 :    
294 :     /**
295 :     * timed poll() blocks interruptibly when empty
296 :     */
297 :     public void testTimedPollFromEmptyBlocksInterruptibly() {
298 :     final BlockingQueue q = emptyCollection();
299 :     final CountDownLatch threadStarted = new CountDownLatch(1);
300 :     Thread t = newStartedThread(new CheckedRunnable() {
301 :     public void realRun() {
302 :     threadStarted.countDown();
303 :     try {
304 :     q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
305 :     shouldThrow();
306 :     } catch (InterruptedException success) {}
307 :     assertFalse(Thread.interrupted());
308 :     }});
309 :    
310 :     await(threadStarted);
311 : jsr166 1.18 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
312 : jsr166 1.7 t.interrupt();
313 :     awaitTermination(t);
314 :     }
315 :    
316 :     /**
317 :     * timed poll() throws InterruptedException immediately if
318 :     * interrupted before waiting
319 :     */
320 :     public void testTimedPollFromEmptyAfterInterrupt() {
321 :     final BlockingQueue q = emptyCollection();
322 :     Thread t = newStartedThread(new CheckedRunnable() {
323 :     public void realRun() {
324 :     Thread.currentThread().interrupt();
325 :     try {
326 :     q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
327 :     shouldThrow();
328 :     } catch (InterruptedException success) {}
329 :     assertFalse(Thread.interrupted());
330 : jsr166 1.3 }});
331 :    
332 : jsr166 1.7 awaitTermination(t);
333 : jsr166 1.2 }
334 :    
335 : jsr166 1.12 /**
336 :     * remove(x) removes x and returns true if present
337 :     * TODO: move to superclass CollectionTest.java
338 :     */
339 :     public void testRemoveElement() {
340 :     final BlockingQueue q = emptyCollection();
341 :     final int size = Math.min(q.remainingCapacity(), SIZE);
342 :     final Object[] elts = new Object[size];
343 :     assertFalse(q.contains(makeElement(99)));
344 :     assertFalse(q.remove(makeElement(99)));
345 :     checkEmpty(q);
346 :     for (int i = 0; i < size; i++)
347 :     q.add(elts[i] = makeElement(i));
348 : jsr166 1.14 for (int i = 1; i < size; i += 2) {
349 : jsr166 1.12 for (int pass = 0; pass < 2; pass++) {
350 :     assertEquals((pass == 0), q.contains(elts[i]));
351 :     assertEquals((pass == 0), q.remove(elts[i]));
352 :     assertFalse(q.contains(elts[i]));
353 : jsr166 1.16 assertTrue(q.contains(elts[i - 1]));
354 : jsr166 1.12 if (i < size - 1)
355 : jsr166 1.16 assertTrue(q.contains(elts[i + 1]));
356 : jsr166 1.12 }
357 :     }
358 :     if (size > 0)
359 :     assertTrue(q.contains(elts[0]));
360 : jsr166 1.15 for (int i = size - 2; i >= 0; i -= 2) {
361 : jsr166 1.12 assertTrue(q.contains(elts[i]));
362 : jsr166 1.16 assertFalse(q.contains(elts[i + 1]));
363 : jsr166 1.12 assertTrue(q.remove(elts[i]));
364 :     assertFalse(q.contains(elts[i]));
365 : jsr166 1.16 assertFalse(q.remove(elts[i + 1]));
366 :     assertFalse(q.contains(elts[i + 1]));
367 : jsr166 1.12 }
368 :     checkEmpty(q);
369 :     }
370 :    
371 : jsr166 1.1 /** For debugging. */
372 :     public void XXXXtestFails() {
373 :     fail(emptyCollection().getClass().toString());
374 :     }
375 :    
376 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8