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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.15 - (show annotations)
Sun May 24 01:23:17 2015 UTC (4 years, 3 months ago) by jsr166
Branch: MAIN
Changes since 1.14: +1 -1 lines
coding style

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 * explained at http://creativecommons.org/publicdomain/zero/1.0/
5 *
6 * Other contributors include Andrew Wright, Jeffrey Hayes,
7 * Pat Fisher, Mike Judd.
8 */
9
10 import static java.util.concurrent.TimeUnit.MILLISECONDS;
11
12 import java.util.ArrayList;
13 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
19 import junit.framework.Test;
20 import junit.framework.TestSuite;
21
22 /**
23 * Contains "contract" tests applicable to all BlockingQueue implementations.
24 */
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 //----------------------------------------------------------------
44 // Configuration methods
45 //----------------------------------------------------------------
46
47 /** Returns an empty instance of the implementation class. */
48 protected abstract BlockingQueue emptyCollection();
49
50 /**
51 * 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
62 /**
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 * drainTo(c, n) returns 0 and does nothing when n <= 0
188 */
189 public void testDrainToNonPositiveMaxElements() {
190 final BlockingQueue q = emptyCollection();
191 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 Object one = makeElement(1);
197 q.add(one);
198 ArrayList c = new ArrayList();
199 for (int n : ns)
200 assertEquals(0, q.drainTo(new ArrayList(), n));
201 assertEquals(1, q.size());
202 assertSame(one, q.poll());
203 assertTrue(c.isEmpty());
204 }
205 }
206
207 /**
208 * timed poll before a delayed offer times out; after offer succeeds;
209 * on interruption throws
210 */
211 public void testTimedPollWithOffer() throws InterruptedException {
212 final BlockingQueue q = emptyCollection();
213 final CheckedBarrier barrier = new CheckedBarrier(2);
214 final Object zero = makeElement(0);
215 Thread t = newStartedThread(new CheckedRunnable() {
216 public void realRun() throws InterruptedException {
217 long startTime = System.nanoTime();
218 assertNull(q.poll(timeoutMillis(), MILLISECONDS));
219 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
220
221 barrier.await();
222
223 assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
224
225 Thread.currentThread().interrupt();
226 try {
227 q.poll(LONG_DELAY_MS, MILLISECONDS);
228 shouldThrow();
229 } catch (InterruptedException success) {}
230 assertFalse(Thread.interrupted());
231
232 barrier.await();
233 try {
234 q.poll(LONG_DELAY_MS, MILLISECONDS);
235 shouldThrow();
236 } catch (InterruptedException success) {}
237 assertFalse(Thread.interrupted());
238 }});
239
240 barrier.await();
241 long startTime = System.nanoTime();
242 assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
243 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
244
245 barrier.await();
246 assertThreadStaysAlive(t);
247 t.interrupt();
248 awaitTermination(t);
249 }
250
251 /**
252 * take() blocks interruptibly when empty
253 */
254 public void testTakeFromEmptyBlocksInterruptibly() {
255 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 assertFalse(Thread.interrupted());
265 }});
266
267 await(threadStarted);
268 assertThreadStaysAlive(t);
269 t.interrupt();
270 awaitTermination(t);
271 }
272
273 /**
274 * take() throws InterruptedException immediately if interrupted
275 * before waiting
276 */
277 public void testTakeFromEmptyAfterInterrupt() {
278 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 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 }});
329
330 awaitTermination(t);
331 }
332
333 /**
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 for (int i = 1; i < size; i += 2) {
347 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 for (int i = size - 2; i >= 0; i -= 2) {
359 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 /** For debugging. */
370 public void XXXXtestFails() {
371 fail(emptyCollection().getClass().toString());
372 }
373
374 }

dl@cs.oswego.edu
ViewVC Help
Powered by ViewVC 1.1.27