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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8