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

Diff of /jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1.13  
changed lines
  Added in v.1.32

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8