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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8