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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8