[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.14 - (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.1 }});
239 :    
240 :     barrier.await();
241 : jsr166 1.7 long startTime = System.nanoTime();
242 :     assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
243 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
244 :    
245 : jsr166 1.1 barrier.await();
246 : jsr166 1.7 assertThreadStaysAlive(t);
247 : jsr166 1.1 t.interrupt();
248 : jsr166 1.7 awaitTermination(t);
249 : jsr166 1.1 }
250 :    
251 : jsr166 1.2 /**
252 : jsr166 1.3 * take() blocks interruptibly when empty
253 : jsr166 1.2 */
254 : jsr166 1.7 public void testTakeFromEmptyBlocksInterruptibly() {
255 : jsr166 1.2 final BlockingQueue q = emptyCollection();
256 :     final CountDownLatch threadStarted = new CountDownLatch(1);
257 :     Thread t = newStartedThread(new CheckedRunnable() {
258 :     public void realRun() {
259 :     threadStarted.countDown();
260 :     try {
261 :     q.take();
262 :     shouldThrow();
263 :     } catch (InterruptedException success) {}
264 : jsr166 1.7 assertFalse(Thread.interrupted());
265 : jsr166 1.2 }});
266 : jsr166 1.3
267 : jsr166 1.7 await(threadStarted);
268 :     assertThreadStaysAlive(t);
269 : jsr166 1.2 t.interrupt();
270 : jsr166 1.7 awaitTermination(t);
271 : jsr166 1.3 }
272 :    
273 :     /**
274 :     * take() throws InterruptedException immediately if interrupted
275 :     * before waiting
276 :     */
277 : jsr166 1.7 public void testTakeFromEmptyAfterInterrupt() {
278 : jsr166 1.3 final BlockingQueue q = emptyCollection();
279 :     Thread t = newStartedThread(new CheckedRunnable() {
280 :     public void realRun() {
281 :     Thread.currentThread().interrupt();
282 :     try {
283 :     q.take();
284 :     shouldThrow();
285 :     } catch (InterruptedException success) {}
286 : jsr166 1.7 assertFalse(Thread.interrupted());
287 :     }});
288 :    
289 :     awaitTermination(t);
290 :     }
291 :    
292 :     /**
293 :     * timed poll() blocks interruptibly when empty
294 :     */
295 :     public void testTimedPollFromEmptyBlocksInterruptibly() {
296 :     final BlockingQueue q = emptyCollection();
297 :     final CountDownLatch threadStarted = new CountDownLatch(1);
298 :     Thread t = newStartedThread(new CheckedRunnable() {
299 :     public void realRun() {
300 :     threadStarted.countDown();
301 :     try {
302 :     q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
303 :     shouldThrow();
304 :     } catch (InterruptedException success) {}
305 :     assertFalse(Thread.interrupted());
306 :     }});
307 :    
308 :     await(threadStarted);
309 :     assertThreadStaysAlive(t);
310 :     t.interrupt();
311 :     awaitTermination(t);
312 :     }
313 :    
314 :     /**
315 :     * timed poll() throws InterruptedException immediately if
316 :     * interrupted before waiting
317 :     */
318 :     public void testTimedPollFromEmptyAfterInterrupt() {
319 :     final BlockingQueue q = emptyCollection();
320 :     Thread t = newStartedThread(new CheckedRunnable() {
321 :     public void realRun() {
322 :     Thread.currentThread().interrupt();
323 :     try {
324 :     q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
325 :     shouldThrow();
326 :     } catch (InterruptedException success) {}
327 :     assertFalse(Thread.interrupted());
328 : jsr166 1.3 }});
329 :    
330 : jsr166 1.7 awaitTermination(t);
331 : jsr166 1.2 }
332 :    
333 : jsr166 1.12 /**
334 :     * remove(x) removes x and returns true if present
335 :     * TODO: move to superclass CollectionTest.java
336 :     */
337 :     public void testRemoveElement() {
338 :     final BlockingQueue q = emptyCollection();
339 :     final int size = Math.min(q.remainingCapacity(), SIZE);
340 :     final Object[] elts = new Object[size];
341 :     assertFalse(q.contains(makeElement(99)));
342 :     assertFalse(q.remove(makeElement(99)));
343 :     checkEmpty(q);
344 :     for (int i = 0; i < size; i++)
345 :     q.add(elts[i] = makeElement(i));
346 : jsr166 1.14 for (int i = 1; i < size; i += 2) {
347 : jsr166 1.12 for (int pass = 0; pass < 2; pass++) {
348 :     assertEquals((pass == 0), q.contains(elts[i]));
349 :     assertEquals((pass == 0), q.remove(elts[i]));
350 :     assertFalse(q.contains(elts[i]));
351 :     assertTrue(q.contains(elts[i-1]));
352 :     if (i < size - 1)
353 :     assertTrue(q.contains(elts[i+1]));
354 :     }
355 :     }
356 :     if (size > 0)
357 :     assertTrue(q.contains(elts[0]));
358 : jsr166 1.14 for (int i = size-2; i >= 0; i -= 2) {
359 : jsr166 1.12 assertTrue(q.contains(elts[i]));
360 :     assertFalse(q.contains(elts[i+1]));
361 :     assertTrue(q.remove(elts[i]));
362 :     assertFalse(q.contains(elts[i]));
363 :     assertFalse(q.remove(elts[i+1]));
364 :     assertFalse(q.contains(elts[i+1]));
365 :     }
366 :     checkEmpty(q);
367 :     }
368 :    
369 : jsr166 1.1 /** For debugging. */
370 :     public void XXXXtestFails() {
371 :     fail(emptyCollection().getClass().toString());
372 :     }
373 :    
374 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8