[cvs] / jsr166 / src / test / tck / AbstractQueuedLongSynchronizerTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/AbstractQueuedLongSynchronizerTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.15 - (view) (download)

1 : dl 1.1 /*
2 :     * Written by Doug Lea with assistance from members of JCP JSR-166
3 :     * Expert Group and released to the public domain, as explained at
4 :     * http://creativecommons.org/licenses/publicdomain
5 : jsr166 1.5 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 :     * Pat Fisher, Mike Judd.
7 : dl 1.1 */
8 :    
9 :    
10 :     import junit.framework.*;
11 :     import java.util.*;
12 :     import java.util.concurrent.*;
13 : jsr166 1.12 import static java.util.concurrent.TimeUnit.MILLISECONDS;
14 : dl 1.1 import java.util.concurrent.locks.*;
15 :     import java.io.*;
16 :    
17 :     public class AbstractQueuedLongSynchronizerTest extends JSR166TestCase {
18 :     public static void main(String[] args) {
19 :     junit.textui.TestRunner.run (suite());
20 :     }
21 :     public static Test suite() {
22 :     return new TestSuite(AbstractQueuedLongSynchronizerTest.class);
23 :     }
24 :    
25 :     /**
26 :     * A simple mutex class, adapted from the
27 :     * AbstractQueuedLongSynchronizer javadoc. Exclusive acquire tests
28 :     * exercise this as a sample user extension. Other
29 :     * methods/features of AbstractQueuedLongSynchronizerTest are tested
30 :     * via other test classes, including those for ReentrantLock,
31 :     * ReentrantReadWriteLock, and Semaphore
32 :     */
33 :     static class Mutex extends AbstractQueuedLongSynchronizer {
34 :     // Use value > 32 bits for locked state
35 :     static final long LOCKED = 1 << 48;
36 : jsr166 1.5 public boolean isHeldExclusively() {
37 :     return getState() == LOCKED;
38 : dl 1.1 }
39 : jsr166 1.5
40 : dl 1.1 public boolean tryAcquire(long acquires) {
41 :     return compareAndSetState(0, LOCKED);
42 :     }
43 : jsr166 1.5
44 : dl 1.1 public boolean tryRelease(long releases) {
45 :     if (getState() == 0) throw new IllegalMonitorStateException();
46 :     setState(0);
47 :     return true;
48 :     }
49 : jsr166 1.5
50 : dl 1.1 public AbstractQueuedLongSynchronizer.ConditionObject newCondition() { return new AbstractQueuedLongSynchronizer.ConditionObject(); }
51 :    
52 :     }
53 :    
54 : jsr166 1.5
55 : dl 1.1 /**
56 :     * A simple latch class, to test shared mode.
57 :     */
58 : jsr166 1.5 static class BooleanLatch extends AbstractQueuedLongSynchronizer {
59 : dl 1.1 public boolean isSignalled() { return getState() != 0; }
60 :    
61 :     public long tryAcquireShared(long ignore) {
62 :     return isSignalled()? 1 : -1;
63 :     }
64 : jsr166 1.5
65 : dl 1.1 public boolean tryReleaseShared(long ignore) {
66 :     setState(1 << 62);
67 :     return true;
68 :     }
69 :     }
70 :    
71 :     /**
72 : jsr166 1.10 * A runnable calling acquireInterruptibly that does not expect to
73 :     * be interrupted.
74 : dl 1.1 */
75 : jsr166 1.10 class InterruptibleSyncRunnable extends CheckedRunnable {
76 : dl 1.1 final Mutex sync;
77 :     InterruptibleSyncRunnable(Mutex l) { sync = l; }
78 : jsr166 1.10 public void realRun() throws InterruptedException {
79 :     sync.acquireInterruptibly(1);
80 : dl 1.1 }
81 :     }
82 :    
83 :    
84 :     /**
85 :     * A runnable calling acquireInterruptibly that expects to be
86 : jsr166 1.10 * interrupted.
87 : dl 1.1 */
88 : jsr166 1.10 class InterruptedSyncRunnable extends CheckedInterruptedRunnable {
89 : dl 1.1 final Mutex sync;
90 :     InterruptedSyncRunnable(Mutex l) { sync = l; }
91 : jsr166 1.10 public void realRun() throws InterruptedException {
92 :     sync.acquireInterruptibly(1);
93 : dl 1.1 }
94 :     }
95 :    
96 :     /**
97 :     * isHeldExclusively is false upon construction
98 :     */
99 : jsr166 1.5 public void testIsHeldExclusively() {
100 : jsr166 1.11 Mutex rl = new Mutex();
101 : dl 1.1 assertFalse(rl.isHeldExclusively());
102 :     }
103 : jsr166 1.5
104 : dl 1.1 /**
105 :     * acquiring released sync succeeds
106 :     */
107 : jsr166 1.5 public void testAcquire() {
108 : jsr166 1.11 Mutex rl = new Mutex();
109 : dl 1.1 rl.acquire(1);
110 :     assertTrue(rl.isHeldExclusively());
111 :     rl.release(1);
112 :     assertFalse(rl.isHeldExclusively());
113 :     }
114 :    
115 :     /**
116 :     * tryAcquire on an released sync succeeds
117 :     */
118 : jsr166 1.5 public void testTryAcquire() {
119 : jsr166 1.11 Mutex rl = new Mutex();
120 : dl 1.1 assertTrue(rl.tryAcquire(1));
121 :     assertTrue(rl.isHeldExclusively());
122 :     rl.release(1);
123 :     }
124 :    
125 :     /**
126 :     * hasQueuedThreads reports whether there are waiting threads
127 :     */
128 : jsr166 1.9 public void testhasQueuedThreads() throws InterruptedException {
129 : jsr166 1.11 final Mutex sync = new Mutex();
130 : dl 1.1 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
131 :     Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
132 : jsr166 1.9 assertFalse(sync.hasQueuedThreads());
133 :     sync.acquire(1);
134 :     t1.start();
135 :     Thread.sleep(SHORT_DELAY_MS);
136 :     assertTrue(sync.hasQueuedThreads());
137 :     t2.start();
138 :     Thread.sleep(SHORT_DELAY_MS);
139 :     assertTrue(sync.hasQueuedThreads());
140 :     t1.interrupt();
141 :     Thread.sleep(SHORT_DELAY_MS);
142 :     assertTrue(sync.hasQueuedThreads());
143 :     sync.release(1);
144 :     Thread.sleep(SHORT_DELAY_MS);
145 :     assertFalse(sync.hasQueuedThreads());
146 :     t1.join();
147 :     t2.join();
148 : jsr166 1.5 }
149 : dl 1.1
150 :     /**
151 :     * isQueued(null) throws NPE
152 :     */
153 : jsr166 1.5 public void testIsQueuedNPE() {
154 : jsr166 1.11 final Mutex sync = new Mutex();
155 : dl 1.1 try {
156 :     sync.isQueued(null);
157 :     shouldThrow();
158 : jsr166 1.9 } catch (NullPointerException success) {}
159 : dl 1.1 }
160 :    
161 :     /**
162 :     * isQueued reports whether a thread is queued.
163 :     */
164 : jsr166 1.9 public void testIsQueued() throws InterruptedException {
165 : jsr166 1.11 final Mutex sync = new Mutex();
166 : dl 1.1 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
167 :     Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
168 : jsr166 1.9 assertFalse(sync.isQueued(t1));
169 :     assertFalse(sync.isQueued(t2));
170 :     sync.acquire(1);
171 :     t1.start();
172 :     Thread.sleep(SHORT_DELAY_MS);
173 :     assertTrue(sync.isQueued(t1));
174 :     t2.start();
175 :     Thread.sleep(SHORT_DELAY_MS);
176 :     assertTrue(sync.isQueued(t1));
177 :     assertTrue(sync.isQueued(t2));
178 :     t1.interrupt();
179 :     Thread.sleep(SHORT_DELAY_MS);
180 :     assertFalse(sync.isQueued(t1));
181 :     assertTrue(sync.isQueued(t2));
182 :     sync.release(1);
183 :     Thread.sleep(SHORT_DELAY_MS);
184 :     assertFalse(sync.isQueued(t1));
185 :     Thread.sleep(SHORT_DELAY_MS);
186 :     assertFalse(sync.isQueued(t2));
187 :     t1.join();
188 :     t2.join();
189 : jsr166 1.5 }
190 : dl 1.1
191 :     /**
192 :     * getFirstQueuedThread returns first waiting thread or null if none
193 :     */
194 : jsr166 1.9 public void testGetFirstQueuedThread() throws InterruptedException {
195 : jsr166 1.11 final Mutex sync = new Mutex();
196 : dl 1.1 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
197 :     Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
198 : jsr166 1.9 assertNull(sync.getFirstQueuedThread());
199 :     sync.acquire(1);
200 :     t1.start();
201 :     Thread.sleep(SHORT_DELAY_MS);
202 :     assertEquals(t1, sync.getFirstQueuedThread());
203 :     t2.start();
204 :     Thread.sleep(SHORT_DELAY_MS);
205 :     assertEquals(t1, sync.getFirstQueuedThread());
206 :     t1.interrupt();
207 :     Thread.sleep(SHORT_DELAY_MS);
208 :     Thread.sleep(SHORT_DELAY_MS);
209 :     assertEquals(t2, sync.getFirstQueuedThread());
210 :     sync.release(1);
211 :     Thread.sleep(SHORT_DELAY_MS);
212 :     assertNull(sync.getFirstQueuedThread());
213 :     t1.join();
214 :     t2.join();
215 : jsr166 1.5 }
216 : dl 1.1
217 :    
218 :     /**
219 :     * hasContended reports false if no thread has ever blocked, else true
220 :     */
221 : jsr166 1.9 public void testHasContended() throws InterruptedException {
222 : jsr166 1.11 final Mutex sync = new Mutex();
223 : dl 1.1 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
224 :     Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
225 : jsr166 1.9 assertFalse(sync.hasContended());
226 :     sync.acquire(1);
227 :     t1.start();
228 :     Thread.sleep(SHORT_DELAY_MS);
229 :     assertTrue(sync.hasContended());
230 :     t2.start();
231 :     Thread.sleep(SHORT_DELAY_MS);
232 :     assertTrue(sync.hasContended());
233 :     t1.interrupt();
234 :     Thread.sleep(SHORT_DELAY_MS);
235 :     assertTrue(sync.hasContended());
236 :     sync.release(1);
237 :     Thread.sleep(SHORT_DELAY_MS);
238 :     assertTrue(sync.hasContended());
239 :     t1.join();
240 :     t2.join();
241 : jsr166 1.5 }
242 : dl 1.1
243 :     /**
244 :     * getQueuedThreads includes waiting threads
245 :     */
246 : jsr166 1.9 public void testGetQueuedThreads() throws InterruptedException {
247 : jsr166 1.11 final Mutex sync = new Mutex();
248 : dl 1.1 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
249 :     Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
250 : jsr166 1.9 assertTrue(sync.getQueuedThreads().isEmpty());
251 :     sync.acquire(1);
252 :     assertTrue(sync.getQueuedThreads().isEmpty());
253 :     t1.start();
254 :     Thread.sleep(SHORT_DELAY_MS);
255 :     assertTrue(sync.getQueuedThreads().contains(t1));
256 :     t2.start();
257 :     Thread.sleep(SHORT_DELAY_MS);
258 :     assertTrue(sync.getQueuedThreads().contains(t1));
259 :     assertTrue(sync.getQueuedThreads().contains(t2));
260 :     t1.interrupt();
261 :     Thread.sleep(SHORT_DELAY_MS);
262 :     assertFalse(sync.getQueuedThreads().contains(t1));
263 :     assertTrue(sync.getQueuedThreads().contains(t2));
264 :     sync.release(1);
265 :     Thread.sleep(SHORT_DELAY_MS);
266 :     assertTrue(sync.getQueuedThreads().isEmpty());
267 :     t1.join();
268 :     t2.join();
269 : jsr166 1.5 }
270 : dl 1.1
271 :     /**
272 :     * getExclusiveQueuedThreads includes waiting threads
273 :     */
274 : jsr166 1.9 public void testGetExclusiveQueuedThreads() throws InterruptedException {
275 : jsr166 1.11 final Mutex sync = new Mutex();
276 : dl 1.1 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
277 :     Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
278 : jsr166 1.9 assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
279 :     sync.acquire(1);
280 :     assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
281 :     t1.start();
282 :     Thread.sleep(SHORT_DELAY_MS);
283 :     assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
284 :     t2.start();
285 :     Thread.sleep(SHORT_DELAY_MS);
286 :     assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
287 :     assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
288 :     t1.interrupt();
289 :     Thread.sleep(SHORT_DELAY_MS);
290 :     assertFalse(sync.getExclusiveQueuedThreads().contains(t1));
291 :     assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
292 :     sync.release(1);
293 :     Thread.sleep(SHORT_DELAY_MS);
294 :     assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
295 :     t1.join();
296 :     t2.join();
297 : jsr166 1.5 }
298 : dl 1.1
299 :     /**
300 :     * getSharedQueuedThreads does not include exclusively waiting threads
301 :     */
302 : jsr166 1.9 public void testGetSharedQueuedThreads() throws InterruptedException {
303 : jsr166 1.11 final Mutex sync = new Mutex();
304 : dl 1.1 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
305 :     Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
306 : jsr166 1.9 assertTrue(sync.getSharedQueuedThreads().isEmpty());
307 :     sync.acquire(1);
308 :     assertTrue(sync.getSharedQueuedThreads().isEmpty());
309 :     t1.start();
310 :     Thread.sleep(SHORT_DELAY_MS);
311 :     assertTrue(sync.getSharedQueuedThreads().isEmpty());
312 :     t2.start();
313 :     Thread.sleep(SHORT_DELAY_MS);
314 :     assertTrue(sync.getSharedQueuedThreads().isEmpty());
315 :     t1.interrupt();
316 :     Thread.sleep(SHORT_DELAY_MS);
317 :     assertTrue(sync.getSharedQueuedThreads().isEmpty());
318 :     sync.release(1);
319 :     Thread.sleep(SHORT_DELAY_MS);
320 :     assertTrue(sync.getSharedQueuedThreads().isEmpty());
321 :     t1.join();
322 :     t2.join();
323 : jsr166 1.5 }
324 : dl 1.1
325 :     /**
326 :     * tryAcquireNanos is interruptible.
327 :     */
328 : jsr166 1.9 public void testInterruptedException2() throws InterruptedException {
329 : jsr166 1.11 final Mutex sync = new Mutex();
330 :     sync.acquire(1);
331 :     Thread t = new Thread(new CheckedInterruptedRunnable() {
332 : jsr166 1.10 public void realRun() throws InterruptedException {
333 : jsr166 1.15 sync.tryAcquireNanos(1, MILLISECONDS.toNanos(MEDIUM_DELAY_MS));
334 : jsr166 1.10 }});
335 : jsr166 1.9
336 :     t.start();
337 : jsr166 1.14 Thread.sleep(SHORT_DELAY_MS);
338 : jsr166 1.9 t.interrupt();
339 :     t.join();
340 : dl 1.1 }
341 :    
342 :    
343 :     /**
344 :     * TryAcquire on exclusively held sync fails
345 :     */
346 : jsr166 1.9 public void testTryAcquireWhenSynced() throws InterruptedException {
347 : jsr166 1.11 final Mutex sync = new Mutex();
348 :     sync.acquire(1);
349 :     Thread t = new Thread(new CheckedRunnable() {
350 : jsr166 1.10 public void realRun() {
351 :     threadAssertFalse(sync.tryAcquire(1));
352 :     }});
353 : jsr166 1.9
354 :     t.start();
355 :     t.join();
356 :     sync.release(1);
357 : jsr166 1.5 }
358 : dl 1.1
359 :     /**
360 :     * tryAcquireNanos on an exclusively held sync times out
361 :     */
362 : jsr166 1.9 public void testAcquireNanos_Timeout() throws InterruptedException {
363 : jsr166 1.11 final Mutex sync = new Mutex();
364 :     sync.acquire(1);
365 :     Thread t = new Thread(new CheckedRunnable() {
366 : jsr166 1.10 public void realRun() throws InterruptedException {
367 : jsr166 1.15 long nanos = MILLISECONDS.toNanos(SHORT_DELAY_MS);
368 :     assertFalse(sync.tryAcquireNanos(1, nanos));
369 : jsr166 1.10 }});
370 : jsr166 1.9
371 :     t.start();
372 :     t.join();
373 :     sync.release(1);
374 : jsr166 1.5 }
375 :    
376 :    
377 : dl 1.1 /**
378 :     * getState is true when acquired and false when not
379 :     */
380 : jsr166 1.9 public void testGetState() throws InterruptedException {
381 : jsr166 1.11 final Mutex sync = new Mutex();
382 :     sync.acquire(1);
383 :     assertTrue(sync.isHeldExclusively());
384 :     sync.release(1);
385 :     assertFalse(sync.isHeldExclusively());
386 :     Thread t = new Thread(new CheckedRunnable() {
387 : jsr166 1.10 public void realRun() throws InterruptedException {
388 :     sync.acquire(1);
389 :     Thread.sleep(SMALL_DELAY_MS);
390 :     sync.release(1);
391 :     }});
392 : jsr166 1.9
393 :     t.start();
394 :     Thread.sleep(SHORT_DELAY_MS);
395 :     assertTrue(sync.isHeldExclusively());
396 :     t.join();
397 :     assertFalse(sync.isHeldExclusively());
398 : dl 1.1 }
399 :    
400 :    
401 :     /**
402 :     * acquireInterruptibly is interruptible.
403 :     */
404 : jsr166 1.9 public void testAcquireInterruptibly1() throws InterruptedException {
405 : jsr166 1.11 final Mutex sync = new Mutex();
406 :     sync.acquire(1);
407 :     Thread t = new Thread(new InterruptedSyncRunnable(sync));
408 : jsr166 1.9 t.start();
409 :     Thread.sleep(SHORT_DELAY_MS);
410 :     t.interrupt();
411 :     Thread.sleep(SHORT_DELAY_MS);
412 :     sync.release(1);
413 :     t.join();
414 : jsr166 1.5 }
415 : dl 1.1
416 :     /**
417 :     * acquireInterruptibly succeeds when released, else is interruptible
418 :     */
419 : jsr166 1.9 public void testAcquireInterruptibly2() throws InterruptedException {
420 : jsr166 1.11 final Mutex sync = new Mutex();
421 : jsr166 1.9 sync.acquireInterruptibly(1);
422 : jsr166 1.11 Thread t = new Thread(new InterruptedSyncRunnable(sync));
423 : jsr166 1.9 t.start();
424 : jsr166 1.14 Thread.sleep(SHORT_DELAY_MS);
425 : jsr166 1.9 t.interrupt();
426 :     assertTrue(sync.isHeldExclusively());
427 :     t.join();
428 : dl 1.1 }
429 :    
430 :     /**
431 :     * owns is true for a condition created by sync else false
432 :     */
433 :     public void testOwns() {
434 : jsr166 1.11 final Mutex sync = new Mutex();
435 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
436 :     final Mutex sync2 = new Mutex();
437 :     assertTrue(sync.owns(c));
438 :     assertFalse(sync2.owns(c));
439 :     }
440 :    
441 :     /**
442 :     * Calling await without holding sync throws IllegalMonitorStateException
443 :     */
444 : jsr166 1.9 public void testAwait_IllegalMonitor() throws InterruptedException {
445 : jsr166 1.11 final Mutex sync = new Mutex();
446 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
447 :     try {
448 :     c.await();
449 :     shouldThrow();
450 : jsr166 1.10 } catch (IllegalMonitorStateException success) {}
451 : dl 1.1 }
452 :    
453 :     /**
454 :     * Calling signal without holding sync throws IllegalMonitorStateException
455 :     */
456 : jsr166 1.9 public void testSignal_IllegalMonitor() throws InterruptedException {
457 : jsr166 1.11 final Mutex sync = new Mutex();
458 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
459 :     try {
460 :     c.signal();
461 :     shouldThrow();
462 : jsr166 1.10 } catch (IllegalMonitorStateException success) {}
463 : dl 1.1 }
464 :    
465 :     /**
466 :     * awaitNanos without a signal times out
467 :     */
468 : jsr166 1.9 public void testAwaitNanos_Timeout() throws InterruptedException {
469 : jsr166 1.11 final Mutex sync = new Mutex();
470 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
471 : jsr166 1.9 sync.acquire(1);
472 :     long t = c.awaitNanos(100);
473 :     assertTrue(t <= 0);
474 :     sync.release(1);
475 : dl 1.1 }
476 :    
477 :     /**
478 :     * Timed await without a signal times out
479 :     */
480 : jsr166 1.9 public void testAwait_Timeout() throws InterruptedException {
481 : jsr166 1.11 final Mutex sync = new Mutex();
482 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
483 : jsr166 1.9 sync.acquire(1);
484 : jsr166 1.12 assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
485 : jsr166 1.9 sync.release(1);
486 : dl 1.1 }
487 :    
488 :     /**
489 :     * awaitUntil without a signal times out
490 :     */
491 : jsr166 1.9 public void testAwaitUntil_Timeout() throws InterruptedException {
492 : jsr166 1.11 final Mutex sync = new Mutex();
493 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
494 : jsr166 1.9 sync.acquire(1);
495 :     java.util.Date d = new java.util.Date();
496 :     assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
497 :     sync.release(1);
498 : dl 1.1 }
499 :    
500 :     /**
501 :     * await returns when signalled
502 :     */
503 : jsr166 1.9 public void testAwait() throws InterruptedException {
504 : jsr166 1.11 final Mutex sync = new Mutex();
505 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
506 : jsr166 1.11 Thread t = new Thread(new CheckedRunnable() {
507 : jsr166 1.10 public void realRun() throws InterruptedException {
508 :     sync.acquire(1);
509 :     c.await();
510 :     sync.release(1);
511 :     }});
512 : dl 1.1
513 : jsr166 1.9 t.start();
514 :     Thread.sleep(SHORT_DELAY_MS);
515 :     sync.acquire(1);
516 :     c.signal();
517 :     sync.release(1);
518 :     t.join(SHORT_DELAY_MS);
519 :     assertFalse(t.isAlive());
520 : dl 1.1 }
521 :    
522 :    
523 :    
524 :     /**
525 :     * hasWaiters throws NPE if null
526 :     */
527 :     public void testHasWaitersNPE() {
528 : jsr166 1.11 final Mutex sync = new Mutex();
529 : dl 1.1 try {
530 :     sync.hasWaiters(null);
531 :     shouldThrow();
532 : jsr166 1.9 } catch (NullPointerException success) {}
533 : dl 1.1 }
534 :    
535 :     /**
536 :     * getWaitQueueLength throws NPE if null
537 :     */
538 :     public void testGetWaitQueueLengthNPE() {
539 : jsr166 1.11 final Mutex sync = new Mutex();
540 : dl 1.1 try {
541 :     sync.getWaitQueueLength(null);
542 :     shouldThrow();
543 : jsr166 1.9 } catch (NullPointerException success) {}
544 : dl 1.1 }
545 :    
546 :    
547 :     /**
548 :     * getWaitingThreads throws NPE if null
549 :     */
550 :     public void testGetWaitingThreadsNPE() {
551 : jsr166 1.11 final Mutex sync = new Mutex();
552 : dl 1.1 try {
553 :     sync.getWaitingThreads(null);
554 :     shouldThrow();
555 : jsr166 1.9 } catch (NullPointerException success) {}
556 : dl 1.1 }
557 :    
558 :    
559 :     /**
560 :     * hasWaiters throws IAE if not owned
561 :     */
562 :     public void testHasWaitersIAE() {
563 : jsr166 1.11 final Mutex sync = new Mutex();
564 : jsr166 1.8 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
565 : jsr166 1.11 final Mutex sync2 = new Mutex();
566 : dl 1.1 try {
567 :     sync2.hasWaiters(c);
568 :     shouldThrow();
569 : jsr166 1.9 } catch (IllegalArgumentException success) {}
570 : dl 1.1 }
571 :    
572 :     /**
573 :     * hasWaiters throws IMSE if not synced
574 :     */
575 :     public void testHasWaitersIMSE() {
576 : jsr166 1.11 final Mutex sync = new Mutex();
577 : jsr166 1.8 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
578 : dl 1.1 try {
579 :     sync.hasWaiters(c);
580 :     shouldThrow();
581 : jsr166 1.9 } catch (IllegalMonitorStateException success) {}
582 : dl 1.1 }
583 :    
584 :    
585 :     /**
586 :     * getWaitQueueLength throws IAE if not owned
587 :     */
588 :     public void testGetWaitQueueLengthIAE() {
589 : jsr166 1.11 final Mutex sync = new Mutex();
590 : jsr166 1.8 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
591 : jsr166 1.11 final Mutex sync2 = new Mutex();
592 : dl 1.1 try {
593 :     sync2.getWaitQueueLength(c);
594 :     shouldThrow();
595 : jsr166 1.9 } catch (IllegalArgumentException success) {}
596 : dl 1.1 }
597 :    
598 :     /**
599 :     * getWaitQueueLength throws IMSE if not synced
600 :     */
601 :     public void testGetWaitQueueLengthIMSE() {
602 : jsr166 1.11 final Mutex sync = new Mutex();
603 : jsr166 1.8 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
604 : dl 1.1 try {
605 :     sync.getWaitQueueLength(c);
606 :     shouldThrow();
607 : jsr166 1.9 } catch (IllegalMonitorStateException success) {}
608 : dl 1.1 }
609 :    
610 :    
611 :     /**
612 :     * getWaitingThreads throws IAE if not owned
613 :     */
614 :     public void testGetWaitingThreadsIAE() {
615 : jsr166 1.11 final Mutex sync = new Mutex();
616 : jsr166 1.8 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
617 : jsr166 1.11 final Mutex sync2 = new Mutex();
618 : dl 1.1 try {
619 :     sync2.getWaitingThreads(c);
620 :     shouldThrow();
621 : jsr166 1.9 } catch (IllegalArgumentException success) {}
622 : dl 1.1 }
623 :    
624 :     /**
625 :     * getWaitingThreads throws IMSE if not synced
626 :     */
627 :     public void testGetWaitingThreadsIMSE() {
628 : jsr166 1.11 final Mutex sync = new Mutex();
629 : jsr166 1.8 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
630 : dl 1.1 try {
631 :     sync.getWaitingThreads(c);
632 :     shouldThrow();
633 : jsr166 1.9 } catch (IllegalMonitorStateException success) {}
634 : dl 1.1 }
635 :    
636 :    
637 :    
638 :     /**
639 :     * hasWaiters returns true when a thread is waiting, else false
640 :     */
641 : jsr166 1.9 public void testHasWaiters() throws InterruptedException {
642 : jsr166 1.11 final Mutex sync = new Mutex();
643 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
644 : jsr166 1.11 Thread t = new Thread(new CheckedRunnable() {
645 : jsr166 1.10 public void realRun() throws InterruptedException {
646 :     sync.acquire(1);
647 :     threadAssertFalse(sync.hasWaiters(c));
648 :     threadAssertEquals(0, sync.getWaitQueueLength(c));
649 :     c.await();
650 :     sync.release(1);
651 :     }});
652 : dl 1.1
653 : jsr166 1.9 t.start();
654 :     Thread.sleep(SHORT_DELAY_MS);
655 :     sync.acquire(1);
656 :     assertTrue(sync.hasWaiters(c));
657 :     assertEquals(1, sync.getWaitQueueLength(c));
658 :     c.signal();
659 :     sync.release(1);
660 :     Thread.sleep(SHORT_DELAY_MS);
661 :     sync.acquire(1);
662 :     assertFalse(sync.hasWaiters(c));
663 :     assertEquals(0, sync.getWaitQueueLength(c));
664 :     sync.release(1);
665 :     t.join(SHORT_DELAY_MS);
666 :     assertFalse(t.isAlive());
667 : dl 1.1 }
668 :    
669 :     /**
670 :     * getWaitQueueLength returns number of waiting threads
671 :     */
672 : jsr166 1.9 public void testGetWaitQueueLength() throws InterruptedException {
673 : jsr166 1.11 final Mutex sync = new Mutex();
674 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
675 : jsr166 1.11 Thread t1 = new Thread(new CheckedRunnable() {
676 : jsr166 1.10 public void realRun() throws InterruptedException {
677 :     sync.acquire(1);
678 :     threadAssertFalse(sync.hasWaiters(c));
679 :     threadAssertEquals(0, sync.getWaitQueueLength(c));
680 :     c.await();
681 :     sync.release(1);
682 :     }});
683 :    
684 : jsr166 1.11 Thread t2 = new Thread(new CheckedRunnable() {
685 : jsr166 1.10 public void realRun() throws InterruptedException {
686 :     sync.acquire(1);
687 :     threadAssertTrue(sync.hasWaiters(c));
688 :     threadAssertEquals(1, sync.getWaitQueueLength(c));
689 :     c.await();
690 :     sync.release(1);
691 :     }});
692 : dl 1.1
693 : jsr166 1.9 t1.start();
694 :     Thread.sleep(SHORT_DELAY_MS);
695 :     t2.start();
696 :     Thread.sleep(SHORT_DELAY_MS);
697 :     sync.acquire(1);
698 :     assertTrue(sync.hasWaiters(c));
699 :     assertEquals(2, sync.getWaitQueueLength(c));
700 :     c.signalAll();
701 :     sync.release(1);
702 :     Thread.sleep(SHORT_DELAY_MS);
703 :     sync.acquire(1);
704 :     assertFalse(sync.hasWaiters(c));
705 :     assertEquals(0, sync.getWaitQueueLength(c));
706 :     sync.release(1);
707 :     t1.join(SHORT_DELAY_MS);
708 :     t2.join(SHORT_DELAY_MS);
709 :     assertFalse(t1.isAlive());
710 :     assertFalse(t2.isAlive());
711 : dl 1.1 }
712 :    
713 :     /**
714 :     * getWaitingThreads returns only and all waiting threads
715 :     */
716 : jsr166 1.9 public void testGetWaitingThreads() throws InterruptedException {
717 : jsr166 1.11 final Mutex sync = new Mutex();
718 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
719 : jsr166 1.11 Thread t1 = new Thread(new CheckedRunnable() {
720 : jsr166 1.10 public void realRun() throws InterruptedException {
721 :     sync.acquire(1);
722 :     threadAssertTrue(sync.getWaitingThreads(c).isEmpty());
723 :     c.await();
724 :     sync.release(1);
725 :     }});
726 :    
727 : jsr166 1.11 Thread t2 = new Thread(new CheckedRunnable() {
728 : jsr166 1.10 public void realRun() throws InterruptedException {
729 :     sync.acquire(1);
730 :     threadAssertFalse(sync.getWaitingThreads(c).isEmpty());
731 :     c.await();
732 :     sync.release(1);
733 :     }});
734 : dl 1.1
735 :     sync.acquire(1);
736 :     assertTrue(sync.getWaitingThreads(c).isEmpty());
737 :     sync.release(1);
738 :     t1.start();
739 :     Thread.sleep(SHORT_DELAY_MS);
740 :     t2.start();
741 :     Thread.sleep(SHORT_DELAY_MS);
742 :     sync.acquire(1);
743 :     assertTrue(sync.hasWaiters(c));
744 :     assertTrue(sync.getWaitingThreads(c).contains(t1));
745 :     assertTrue(sync.getWaitingThreads(c).contains(t2));
746 :     c.signalAll();
747 :     sync.release(1);
748 :     Thread.sleep(SHORT_DELAY_MS);
749 :     sync.acquire(1);
750 :     assertFalse(sync.hasWaiters(c));
751 :     assertTrue(sync.getWaitingThreads(c).isEmpty());
752 :     sync.release(1);
753 :     t1.join(SHORT_DELAY_MS);
754 :     t2.join(SHORT_DELAY_MS);
755 :     assertFalse(t1.isAlive());
756 :     assertFalse(t2.isAlive());
757 :     }
758 :    
759 :    
760 :    
761 :     /**
762 :     * awaitUninterruptibly doesn't abort on interrupt
763 :     */
764 : jsr166 1.9 public void testAwaitUninterruptibly() throws InterruptedException {
765 : jsr166 1.11 final Mutex sync = new Mutex();
766 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
767 : jsr166 1.11 Thread t = new Thread(new CheckedRunnable() {
768 : jsr166 1.10 public void realRun() {
769 :     sync.acquire(1);
770 :     c.awaitUninterruptibly();
771 :     sync.release(1);
772 :     }});
773 : dl 1.1
774 : jsr166 1.9 t.start();
775 :     Thread.sleep(SHORT_DELAY_MS);
776 :     t.interrupt();
777 :     sync.acquire(1);
778 :     c.signal();
779 :     sync.release(1);
780 :     t.join(SHORT_DELAY_MS);
781 :     assertFalse(t.isAlive());
782 : dl 1.1 }
783 :    
784 :     /**
785 :     * await is interruptible
786 :     */
787 : jsr166 1.9 public void testAwait_Interrupt() throws InterruptedException {
788 : jsr166 1.11 final Mutex sync = new Mutex();
789 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
790 : jsr166 1.11 Thread t = new Thread(new CheckedInterruptedRunnable() {
791 :     public void realRun() throws InterruptedException {
792 : jsr166 1.10 sync.acquire(1);
793 :     c.await();
794 :     }});
795 : dl 1.1
796 : jsr166 1.9 t.start();
797 :     Thread.sleep(SHORT_DELAY_MS);
798 :     t.interrupt();
799 :     t.join(SHORT_DELAY_MS);
800 :     assertFalse(t.isAlive());
801 : dl 1.1 }
802 :    
803 :     /**
804 :     * awaitNanos is interruptible
805 :     */
806 : jsr166 1.9 public void testAwaitNanos_Interrupt() throws InterruptedException {
807 : jsr166 1.11 final Mutex sync = new Mutex();
808 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
809 : jsr166 1.11 Thread t = new Thread(new CheckedInterruptedRunnable() {
810 :     public void realRun() throws InterruptedException {
811 : jsr166 1.10 sync.acquire(1);
812 : jsr166 1.15 c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
813 : jsr166 1.10 }});
814 : dl 1.1
815 : jsr166 1.9 t.start();
816 :     Thread.sleep(SHORT_DELAY_MS);
817 :     t.interrupt();
818 :     t.join(SHORT_DELAY_MS);
819 :     assertFalse(t.isAlive());
820 : dl 1.1 }
821 :    
822 :     /**
823 :     * awaitUntil is interruptible
824 :     */
825 : jsr166 1.9 public void testAwaitUntil_Interrupt() throws InterruptedException {
826 : jsr166 1.11 final Mutex sync = new Mutex();
827 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
828 : jsr166 1.11 Thread t = new Thread(new CheckedInterruptedRunnable() {
829 :     public void realRun() throws InterruptedException {
830 : jsr166 1.10 sync.acquire(1);
831 :     java.util.Date d = new java.util.Date();
832 :     c.awaitUntil(new java.util.Date(d.getTime() + 10000));
833 :     }});
834 : dl 1.1
835 : jsr166 1.9 t.start();
836 :     Thread.sleep(SHORT_DELAY_MS);
837 :     t.interrupt();
838 :     t.join(SHORT_DELAY_MS);
839 :     assertFalse(t.isAlive());
840 : dl 1.1 }
841 :    
842 :     /**
843 :     * signalAll wakes up all threads
844 :     */
845 : jsr166 1.9 public void testSignalAll() throws InterruptedException {
846 : jsr166 1.11 final Mutex sync = new Mutex();
847 : dl 1.1 final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
848 : jsr166 1.11 Thread t1 = new Thread(new CheckedRunnable() {
849 : jsr166 1.10 public void realRun() throws InterruptedException {
850 :     sync.acquire(1);
851 :     c.await();
852 :     sync.release(1);
853 :     }});
854 :    
855 : jsr166 1.11 Thread t2 = new Thread(new CheckedRunnable() {
856 : jsr166 1.10 public void realRun() throws InterruptedException {
857 :     sync.acquire(1);
858 :     c.await();
859 :     sync.release(1);
860 :     }});
861 : dl 1.1
862 : jsr166 1.9 t1.start();
863 :     t2.start();
864 :     Thread.sleep(SHORT_DELAY_MS);
865 :     sync.acquire(1);
866 :     c.signalAll();
867 :     sync.release(1);
868 :     t1.join(SHORT_DELAY_MS);
869 :     t2.join(SHORT_DELAY_MS);
870 :     assertFalse(t1.isAlive());
871 :     assertFalse(t2.isAlive());
872 : dl 1.1 }
873 :    
874 :    
875 :     /**
876 :     * toString indicates current state
877 :     */
878 :     public void testToString() {
879 :     Mutex sync = new Mutex();
880 :     String us = sync.toString();
881 :     assertTrue(us.indexOf("State = 0") >= 0);
882 :     sync.acquire(1);
883 :     String ls = sync.toString();
884 :     assertTrue(ls.indexOf("State = " + Mutex.LOCKED) >= 0);
885 :     }
886 :    
887 :     /**
888 :     * A serialized AQS deserializes with current state
889 :     */
890 : jsr166 1.9 public void testSerialization() throws Exception {
891 : dl 1.1 Mutex l = new Mutex();
892 :     l.acquire(1);
893 :     assertTrue(l.isHeldExclusively());
894 :    
895 : jsr166 1.9 ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
896 :     ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
897 :     out.writeObject(l);
898 :     out.close();
899 :    
900 :     ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
901 :     ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
902 :     Mutex r = (Mutex) in.readObject();
903 :     assertTrue(r.isHeldExclusively());
904 : dl 1.1 }
905 :    
906 :    
907 :     /**
908 :     * tryReleaseShared setting state changes getState
909 :     */
910 :     public void testGetStateWithReleaseShared() {
911 : jsr166 1.11 final BooleanLatch l = new BooleanLatch();
912 :     assertFalse(l.isSignalled());
913 :     l.releaseShared(0);
914 :     assertTrue(l.isSignalled());
915 : dl 1.1 }
916 :    
917 :     /**
918 :     * releaseShared has no effect when already signalled
919 :     */
920 :     public void testReleaseShared() {
921 : jsr166 1.11 final BooleanLatch l = new BooleanLatch();
922 :     assertFalse(l.isSignalled());
923 :     l.releaseShared(0);
924 :     assertTrue(l.isSignalled());
925 :     l.releaseShared(0);
926 :     assertTrue(l.isSignalled());
927 : dl 1.1 }
928 :    
929 :     /**
930 :     * acquireSharedInterruptibly returns after release, but not before
931 :     */
932 : jsr166 1.9 public void testAcquireSharedInterruptibly() throws InterruptedException {
933 : jsr166 1.11 final BooleanLatch l = new BooleanLatch();
934 : dl 1.1
935 : jsr166 1.11 Thread t = new Thread(new CheckedRunnable() {
936 : jsr166 1.10 public void realRun() throws InterruptedException {
937 :     threadAssertFalse(l.isSignalled());
938 :     l.acquireSharedInterruptibly(0);
939 :     threadAssertTrue(l.isSignalled());
940 :     }});
941 : jsr166 1.9
942 :     t.start();
943 :     assertFalse(l.isSignalled());
944 :     Thread.sleep(SHORT_DELAY_MS);
945 :     l.releaseShared(0);
946 :     assertTrue(l.isSignalled());
947 :     t.join();
948 : dl 1.1 }
949 : jsr166 1.5
950 : dl 1.1
951 :     /**
952 :     * acquireSharedTimed returns after release
953 :     */
954 : jsr166 1.9 public void testAsquireSharedTimed() throws InterruptedException {
955 : jsr166 1.11 final BooleanLatch l = new BooleanLatch();
956 : dl 1.1
957 : jsr166 1.11 Thread t = new Thread(new CheckedRunnable() {
958 : jsr166 1.10 public void realRun() throws InterruptedException {
959 : jsr166 1.15 assertFalse(l.isSignalled());
960 :     long nanos = MILLISECONDS.toNanos(MEDIUM_DELAY_MS);
961 :     assertTrue(l.tryAcquireSharedNanos(0, nanos));
962 :     assertTrue(l.isSignalled());
963 : jsr166 1.10 }});
964 : jsr166 1.9
965 :     t.start();
966 :     assertFalse(l.isSignalled());
967 :     Thread.sleep(SHORT_DELAY_MS);
968 :     l.releaseShared(0);
969 :     assertTrue(l.isSignalled());
970 :     t.join();
971 : dl 1.1 }
972 : jsr166 1.5
973 : dl 1.1 /**
974 :     * acquireSharedInterruptibly throws IE if interrupted before released
975 :     */
976 : jsr166 1.9 public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {
977 : dl 1.1 final BooleanLatch l = new BooleanLatch();
978 : jsr166 1.11 Thread t = new Thread(new CheckedInterruptedRunnable() {
979 :     public void realRun() throws InterruptedException {
980 : jsr166 1.10 threadAssertFalse(l.isSignalled());
981 :     l.acquireSharedInterruptibly(0);
982 :     }});
983 : jsr166 1.9
984 : jsr166 1.11 t.start();
985 : jsr166 1.9 assertFalse(l.isSignalled());
986 :     t.interrupt();
987 :     t.join();
988 : dl 1.1 }
989 :    
990 :     /**
991 :     * acquireSharedTimed throws IE if interrupted before released
992 :     */
993 : jsr166 1.9 public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {
994 : dl 1.1 final BooleanLatch l = new BooleanLatch();
995 : jsr166 1.11 Thread t = new Thread(new CheckedInterruptedRunnable() {
996 :     public void realRun() throws InterruptedException {
997 : jsr166 1.15 assertFalse(l.isSignalled());
998 :     long nanos = MILLISECONDS.toNanos(SMALL_DELAY_MS);
999 :     l.tryAcquireSharedNanos(0, nanos);
1000 : jsr166 1.10 }});
1001 : jsr166 1.9
1002 : dl 1.1 t.start();
1003 : jsr166 1.9 Thread.sleep(SHORT_DELAY_MS);
1004 :     assertFalse(l.isSignalled());
1005 :     t.interrupt();
1006 :     t.join();
1007 : dl 1.1 }
1008 :    
1009 :     /**
1010 :     * acquireSharedTimed times out if not released before timeout
1011 :     */
1012 : jsr166 1.9 public void testAcquireSharedNanos_Timeout() throws InterruptedException {
1013 : dl 1.1 final BooleanLatch l = new BooleanLatch();
1014 : jsr166 1.11 Thread t = new Thread(new CheckedRunnable() {
1015 : jsr166 1.10 public void realRun() throws InterruptedException {
1016 : jsr166 1.15 assertFalse(l.isSignalled());
1017 :     long nanos = MILLISECONDS.toNanos(SMALL_DELAY_MS);
1018 :     assertFalse(l.tryAcquireSharedNanos(0, nanos));
1019 : jsr166 1.10 }});
1020 : jsr166 1.9
1021 : dl 1.1 t.start();
1022 : jsr166 1.9 Thread.sleep(SHORT_DELAY_MS);
1023 :     assertFalse(l.isSignalled());
1024 :     t.join();
1025 : dl 1.1 }
1026 :    
1027 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8