/[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.8 - (show annotations)
Mon May 30 22:43:20 2011 UTC (8 years, 2 months ago) by jsr166
Branch: MAIN
Changes since 1.7: +147 -3 lines
refactor more generic BlockingQueue tests into BlockingQueueTest.java

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

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