[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.16, Sun Jan 11 16:02:33 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 45  Line 46 
46    
47          public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }          public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }
48    
         public void lock() {  
             acquire(1);  
         }  
   
49      }      }
50    
51    
# Line 69  Line 66 
66      }      }
67    
68      /**      /**
69       * A runnable calling acquireInterruptibly       * 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.acquireInterruptibly(1);  
             } catch(InterruptedException success){}  
77          }          }
78      }      }
79    
80    
81      /**      /**
82       * A runnable calling acquireInterruptibly 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);
                 lock.acquireInterruptibly(1);  
                 threadShouldThrow();  
             } catch(InterruptedException success){}  
90          }          }
91      }      }
92    
# Line 106  Line 99 
99      }      }
100    
101      /**      /**
102       * acquiring released lock succeeds       * acquiring released sync succeeds
103       */       */
104      public void testAcquire() {      public void testAcquire() {
105          Mutex rl = new Mutex();          Mutex rl = new Mutex();
106          rl.acquire(1);          rl.acquire(1);
107          assertTrue(rl.isHeldExclusively());          assertTrue(rl.isHeldExclusively());
108          rl.release(1);          rl.release(1);
109            assertFalse(rl.isHeldExclusively());
110      }      }
111    
112      /**      /**
113       * tryAcquire on an released lock succeeds       * tryAcquire on an released sync succeeds
114       */       */
115      public void testTryAcquire() {      public void testTryAcquire() {
116          Mutex rl = new Mutex();          Mutex rl = new Mutex();
# Line 128  Line 122 
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.acquire(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.release(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.acquire(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.release(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.acquire(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.release(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);
224              lock.acquire(1);          t1.start();
225            Thread.sleep(SHORT_DELAY_MS);
226            assertTrue(sync.hasContended());
227            t2.start();
228            Thread.sleep(SHORT_DELAY_MS);
229            assertTrue(sync.hasContended());
230            t1.interrupt();
231            Thread.sleep(SHORT_DELAY_MS);
232            assertTrue(sync.hasContended());
233            sync.release(1);
234            Thread.sleep(SHORT_DELAY_MS);
235            assertTrue(sync.hasContended());
236            t1.join();
237            t2.join();
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();              t1.start();
251              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
252              assertTrue(lock.hasContended());          assertTrue(sync.getQueuedThreads().contains(t1));
253              t2.start();              t2.start();
254              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
255              assertTrue(lock.hasContended());          assertTrue(sync.getQueuedThreads().contains(t1));
256            assertTrue(sync.getQueuedThreads().contains(t2));
257              t1.interrupt();              t1.interrupt();
258              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
259              assertTrue(lock.hasContended());          assertFalse(sync.getQueuedThreads().contains(t1));
260              lock.release(1);          assertTrue(sync.getQueuedThreads().contains(t2));
261            sync.release(1);
262              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
263              assertTrue(lock.hasContended());          assertTrue(sync.getQueuedThreads().isEmpty());
264              t1.join();              t1.join();
265              t2.join();              t2.join();
         } catch(Exception e){  
             unexpectedException();  
266          }          }
267    
268        /**
269         * getExclusiveQueuedThreads includes waiting threads
270         */
271        public void testGetExclusiveQueuedThreads() throws InterruptedException {
272            final Mutex sync = new Mutex();
273            Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
274            Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
275            assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
276            sync.acquire(1);
277            assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
278            t1.start();
279            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      /**      /**
297       * tryAcquireNanos is interruptible.       * getSharedQueuedThreads does not include exclusively waiting threads
298       */       */
299      public void testInterruptedException2() {      public void testGetSharedQueuedThreads() throws InterruptedException {
300          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
301          lock.acquire(1);          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
302          Thread t = new Thread(new Runnable() {          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
303                  public void run() {          assertTrue(sync.getSharedQueuedThreads().isEmpty());
304                      try {          sync.acquire(1);
305                          lock.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);          assertTrue(sync.getSharedQueuedThreads().isEmpty());
306                          threadShouldThrow();          t1.start();
307                      } catch(InterruptedException success){}          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          try {      /**
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       * TryAcquire on a locked lock fails       * TryAcquire on exclusively held sync fails
342       */       */
343      public void testTryAcquireWhenLocked() {      public void testTryAcquireWhenSynced() throws InterruptedException {
344          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
345          lock.acquire(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.tryAcquire(1));                  threadAssertFalse(sync.tryAcquire(1));
349                  }              }});
350              });  
         try {  
351              t.start();              t.start();
352              t.join();              t.join();
353              lock.release(1);          sync.release(1);
         } catch(Exception e){  
             unexpectedException();  
         }  
354      }      }
355    
356      /**      /**
357       * tryAcquireNanos on a locked lock times out       * tryAcquireNanos on an exclusively held sync times out
358       */       */
359      public void testAcquireNanos_Timeout() {      public void testAcquireNanos_Timeout() throws InterruptedException {
360          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
361          lock.acquire(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.tryAcquireNanos(1, 1000 * 1000));              }});
366                      } catch (Exception ex) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
367              t.start();              t.start();
368              t.join();              t.join();
369              lock.release(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.acquire(1);          sync.acquire(1);
379          assertTrue(lock.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
380          lock.release(1);          sync.release(1);
381          assertFalse(lock.isHeldExclusively());          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.acquire(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.release(1);  
                 }  
             });  
         try {  
389              t.start();              t.start();
390              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
391              assertTrue(lock.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
392              t.join();              t.join();
393              assertFalse(lock.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
         } catch(Exception e){  
             unexpectedException();  
         }  
394      }      }
395    
396    
397      /**      /**
398       * acquireInterruptibly 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.acquire(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.release(1);          Thread.sleep(SHORT_DELAY_MS);
409            sync.release(1);
410              t.join();              t.join();
         } catch(Exception e){  
             unexpectedException();  
         }  
411      }      }
412    
413      /**      /**
414       * acquireInterruptibly 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.acquireInterruptibly(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.isHeldExclusively());          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 AbstractQueuedSynchronizer.ConditionObject 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 AbstractQueuedSynchronizer.ConditionObject 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 AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
468          try {          sync.acquire(1);
             lock.acquire(1);  
469              long t = c.awaitNanos(100);              long t = c.awaitNanos(100);
470              assertTrue(t <= 0);              assertTrue(t <= 0);
471              lock.release(1);          sync.release(1);
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
472      }      }
473    
474      /**      /**
475       *  timed await without a signal times out       *  Timed await without a signal times out
476       */       */
477      public void testAwait_Timeout() {      public void testAwait_Timeout() throws InterruptedException {
478          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
479          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
480          try {          sync.acquire(1);
481              lock.acquire(1);          assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
482              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));          sync.release(1);
             lock.release(1);  
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
483      }      }
484    
485      /**      /**
486       * awaitUntil without a signal times out       * awaitUntil without a signal times out
487       */       */
488      public void testAwaitUntil_Timeout() {      public void testAwaitUntil_Timeout() throws InterruptedException {
489          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
490          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
491          try {          sync.acquire(1);
             lock.acquire(1);  
492              java.util.Date d = new java.util.Date();              java.util.Date d = new java.util.Date();
493              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
494              lock.release(1);          sync.release(1);
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
495      }      }
496    
497      /**      /**
498       * await returns when signalled       * await returns when signalled
499       */       */
500      public void testAwait() {      public void testAwait() throws InterruptedException {
501          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
502          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
503          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
504                  public void run() {              public void realRun() throws InterruptedException {
505                      try {                  sync.acquire(1);
                         lock.acquire(1);  
506                          c.await();                          c.await();
507                          lock.release(1);                  sync.release(1);
508                      }              }});
                     catch(InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
509    
         try {  
510              t.start();              t.start();
511              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
512              lock.acquire(1);          sync.acquire(1);
513              c.signal();              c.signal();
514              lock.release(1);          sync.release(1);
515              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
516              assertFalse(t.isAlive());              assertFalse(t.isAlive());
517          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
518    
519    
520    
# Line 531  Line 522 
522       * hasWaiters throws NPE if null       * hasWaiters throws NPE if null
523       */       */
524      public void testHasWaitersNPE() {      public void testHasWaitersNPE() {
525          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
526          try {          try {
527              lock.hasWaiters(null);              sync.hasWaiters(null);
528              shouldThrow();              shouldThrow();
529          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
530      }      }
531    
532      /**      /**
533       * getWaitQueueLength throws NPE if null       * getWaitQueueLength throws NPE if null
534       */       */
535      public void testGetWaitQueueLengthNPE() {      public void testGetWaitQueueLengthNPE() {
536          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
537          try {          try {
538              lock.getWaitQueueLength(null);              sync.getWaitQueueLength(null);
539              shouldThrow();              shouldThrow();
540          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
541      }      }
542    
543    
# Line 560  Line 545 
545       * getWaitingThreads throws NPE if null       * getWaitingThreads throws NPE if null
546       */       */
547      public void testGetWaitingThreadsNPE() {      public void testGetWaitingThreadsNPE() {
548          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
549          try {          try {
550              lock.getWaitingThreads(null);              sync.getWaitingThreads(null);
551              shouldThrow();              shouldThrow();
552          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
553      }      }
554    
555    
# Line 575  Line 557 
557       * hasWaiters throws IAE if not owned       * hasWaiters throws IAE if not owned
558       */       */
559      public void testHasWaitersIAE() {      public void testHasWaitersIAE() {
560          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
561          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
562          final Mutex lock2 = new Mutex();          final Mutex sync2 = new Mutex();
563          try {          try {
564              lock2.hasWaiters(c);              sync2.hasWaiters(c);
565              shouldThrow();              shouldThrow();
566          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
567      }      }
568    
569      /**      /**
570       * hasWaiters throws IMSE if not locked       * hasWaiters throws IMSE if not synced
571       */       */
572      public void testHasWaitersIMSE() {      public void testHasWaitersIMSE() {
573          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
574          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
575          try {          try {
576              lock.hasWaiters(c);              sync.hasWaiters(c);
577              shouldThrow();              shouldThrow();
578          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
579      }      }
580    
581    
# Line 607  Line 583 
583       * getWaitQueueLength throws IAE if not owned       * getWaitQueueLength throws IAE if not owned
584       */       */
585      public void testGetWaitQueueLengthIAE() {      public void testGetWaitQueueLengthIAE() {
586          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
587          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
588          final Mutex lock2 = new Mutex();          final Mutex sync2 = new Mutex();
589          try {          try {
590              lock2.getWaitQueueLength(c);              sync2.getWaitQueueLength(c);
591              shouldThrow();              shouldThrow();
592          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
593      }      }
594    
595      /**      /**
596       * getWaitQueueLength throws IMSE if not locked       * getWaitQueueLength throws IMSE if not synced
597       */       */
598      public void testGetWaitQueueLengthIMSE() {      public void testGetWaitQueueLengthIMSE() {
599          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
600          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
601          try {          try {
602              lock.getWaitQueueLength(c);              sync.getWaitQueueLength(c);
603              shouldThrow();              shouldThrow();
604          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
605      }      }
606    
607    
# Line 639  Line 609 
609       * getWaitingThreads throws IAE if not owned       * getWaitingThreads throws IAE if not owned
610       */       */
611      public void testGetWaitingThreadsIAE() {      public void testGetWaitingThreadsIAE() {
612          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
613          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
614          final Mutex lock2 = new Mutex();          final Mutex sync2 = new Mutex();
615          try {          try {
616              lock2.getWaitingThreads(c);              sync2.getWaitingThreads(c);
617              shouldThrow();              shouldThrow();
618          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
619      }      }
620    
621      /**      /**
622       * getWaitingThreads throws IMSE if not locked       * getWaitingThreads throws IMSE if not synced
623       */       */
624      public void testGetWaitingThreadsIMSE() {      public void testGetWaitingThreadsIMSE() {
625          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
626          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
627          try {          try {
628              lock.getWaitingThreads(c);              sync.getWaitingThreads(c);
629              shouldThrow();              shouldThrow();
630          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
631      }      }
632    
633    
# Line 671  Line 635 
635      /**      /**
636       * hasWaiters returns true when a thread is waiting, else false       * hasWaiters returns true when a thread is waiting, else false
637       */       */
638      public void testHasWaiters() {      public void testHasWaiters() throws InterruptedException {
639          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
640          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
641          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
642                  public void run() {              public void realRun() throws InterruptedException {
643                      try {                  sync.acquire(1);
644                          lock.acquire(1);                  threadAssertFalse(sync.hasWaiters(c));
645                          threadAssertFalse(lock.hasWaiters(c));                  threadAssertEquals(0, sync.getWaitQueueLength(c));
                         threadAssertEquals(0, lock.getWaitQueueLength(c));  
646                          c.await();                          c.await();
647                          lock.release(1);                  sync.release(1);
648                      }              }});
                     catch(InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
649    
         try {  
650              t.start();              t.start();
651              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
652              lock.acquire(1);          sync.acquire(1);
653              assertTrue(lock.hasWaiters(c));          assertTrue(sync.hasWaiters(c));
654              assertEquals(1, lock.getWaitQueueLength(c));          assertEquals(1, sync.getWaitQueueLength(c));
655              c.signal();              c.signal();
656              lock.release(1);          sync.release(1);
657              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
658              lock.acquire(1);          sync.acquire(1);
659              assertFalse(lock.hasWaiters(c));          assertFalse(sync.hasWaiters(c));
660              assertEquals(0, lock.getWaitQueueLength(c));          assertEquals(0, sync.getWaitQueueLength(c));
661              lock.release(1);          sync.release(1);
662              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
663              assertFalse(t.isAlive());              assertFalse(t.isAlive());
664          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
665    
666      /**      /**
667       * getWaitQueueLength returns number of waiting threads       * getWaitQueueLength returns number of waiting threads
668       */       */
669      public void testGetWaitQueueLength() {      public void testGetWaitQueueLength() throws InterruptedException {
670          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
671          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
672          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new CheckedRunnable() {
673                  public void run() {              public void realRun() throws InterruptedException {
674                      try {                  sync.acquire(1);
675                          lock.acquire(1);                  threadAssertFalse(sync.hasWaiters(c));
676                          threadAssertFalse(lock.hasWaiters(c));                  threadAssertEquals(0, sync.getWaitQueueLength(c));
                         threadAssertEquals(0, lock.getWaitQueueLength(c));  
677                          c.await();                          c.await();
678                          lock.release(1);                  sync.release(1);
679                      }              }});
                     catch(InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
680    
681          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new CheckedRunnable() {
682                  public void run() {              public void realRun() throws InterruptedException {
683                      try {                  sync.acquire(1);
684                          lock.acquire(1);                  threadAssertTrue(sync.hasWaiters(c));
685                          threadAssertTrue(lock.hasWaiters(c));                  threadAssertEquals(1, sync.getWaitQueueLength(c));
                         threadAssertEquals(1, lock.getWaitQueueLength(c));  
686                          c.await();                          c.await();
687                          lock.release(1);                  sync.release(1);
688                      }              }});
                     catch(InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
689    
         try {  
690              t1.start();              t1.start();
691              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
692              t2.start();              t2.start();
693              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
694              lock.acquire(1);          sync.acquire(1);
695              assertTrue(lock.hasWaiters(c));          assertTrue(sync.hasWaiters(c));
696              assertEquals(2, lock.getWaitQueueLength(c));          assertEquals(2, sync.getWaitQueueLength(c));
697              c.signalAll();              c.signalAll();
698              lock.release(1);          sync.release(1);
699              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
700              lock.acquire(1);          sync.acquire(1);
701              assertFalse(lock.hasWaiters(c));          assertFalse(sync.hasWaiters(c));
702              assertEquals(0, lock.getWaitQueueLength(c));          assertEquals(0, sync.getWaitQueueLength(c));
703              lock.release(1);          sync.release(1);
704              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
705              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
706              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
707              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
708          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
709    
710      /**      /**
711       * getWaitingThreads returns only and all waiting threads       * getWaitingThreads returns only and all waiting threads
712       */       */
713      public void testGetWaitingThreads() {      public void testGetWaitingThreads() throws InterruptedException {
714          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
715          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
716          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new CheckedRunnable() {
717                  public void run() {              public void realRun() throws InterruptedException {
718                      try {                  sync.acquire(1);
719                          lock.acquire(1);                  threadAssertTrue(sync.getWaitingThreads(c).isEmpty());
                         threadAssertTrue(lock.getWaitingThreads(c).isEmpty());  
720                          c.await();                          c.await();
721                          lock.release(1);                  sync.release(1);
722                      }              }});
                     catch(InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
723    
724          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new CheckedRunnable() {
725                  public void run() {              public void realRun() throws InterruptedException {
726                      try {                  sync.acquire(1);
727                          lock.acquire(1);                  threadAssertFalse(sync.getWaitingThreads(c).isEmpty());
                         threadAssertFalse(lock.getWaitingThreads(c).isEmpty());  
728                          c.await();                          c.await();
729                          lock.release(1);                  sync.release(1);
730                      }              }});
                     catch(InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
731    
732          try {          sync.acquire(1);
733              lock.acquire(1);          assertTrue(sync.getWaitingThreads(c).isEmpty());
734              assertTrue(lock.getWaitingThreads(c).isEmpty());          sync.release(1);
             lock.release(1);  
735              t1.start();              t1.start();
736              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
737              t2.start();              t2.start();
738              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
739              lock.acquire(1);          sync.acquire(1);
740              assertTrue(lock.hasWaiters(c));          assertTrue(sync.hasWaiters(c));
741              assertTrue(lock.getWaitingThreads(c).contains(t1));          assertTrue(sync.getWaitingThreads(c).contains(t1));
742              assertTrue(lock.getWaitingThreads(c).contains(t2));          assertTrue(sync.getWaitingThreads(c).contains(t2));
743              c.signalAll();              c.signalAll();
744              lock.release(1);          sync.release(1);
745              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
746              lock.acquire(1);          sync.acquire(1);
747              assertFalse(lock.hasWaiters(c));          assertFalse(sync.hasWaiters(c));
748              assertTrue(lock.getWaitingThreads(c).isEmpty());          assertTrue(sync.getWaitingThreads(c).isEmpty());
749              lock.release(1);          sync.release(1);
750              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
751              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
752              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
753              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
754          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
755    
756    
757    
758      /**      /**
759       * awaitUninterruptibly doesn't abort on interrupt       * awaitUninterruptibly doesn't abort on interrupt
760       */       */
761      public void testAwaitUninterruptibly() {      public void testAwaitUninterruptibly() throws InterruptedException {
762          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
763          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
764          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
765                  public void run() {              public void realRun() {
766                      lock.acquire(1);                  sync.acquire(1);
767                      c.awaitUninterruptibly();                      c.awaitUninterruptibly();
768                      lock.release(1);                  sync.release(1);
769                  }              }});
             });  
770    
         try {  
771              t.start();              t.start();
772              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
773              t.interrupt();              t.interrupt();
774              lock.acquire(1);          sync.acquire(1);
775              c.signal();              c.signal();
776              lock.release(1);          sync.release(1);
             assert(t.isInterrupted());  
777              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
778              assertFalse(t.isAlive());              assertFalse(t.isAlive());
779          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
780    
781      /**      /**
782       * await is interruptible       * await is interruptible
783       */       */
784      public void testAwait_Interrupt() {      public void testAwait_Interrupt() throws InterruptedException {
785          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
786          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
787          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
788                  public void run() {              public void realRun() throws InterruptedException {
789                      try {                  sync.acquire(1);
                         lock.acquire(1);  
790                          c.await();                          c.await();
791                          lock.release(1);              }});
                         threadShouldThrow();  
                     }  
                     catch(InterruptedException success) {  
                     }  
                 }  
             });  
792    
         try {  
793              t.start();              t.start();
794              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
795              t.interrupt();              t.interrupt();
796              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
797              assertFalse(t.isAlive());              assertFalse(t.isAlive());
798          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
799    
800      /**      /**
801       * awaitNanos is interruptible       * awaitNanos is interruptible
802       */       */
803      public void testAwaitNanos_Interrupt() {      public void testAwaitNanos_Interrupt() throws InterruptedException {
804          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
805          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
806          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
807                  public void run() {              public void realRun() throws InterruptedException {
808                      try {                  sync.acquire(1);
809                          lock.acquire(1);                  c.awaitNanos(LONG_DELAY_MS * 1000L * 1000L);
810                          c.awaitNanos(1000 * 1000 * 1000); // 1 sec              }});
                         lock.release(1);  
                         threadShouldThrow();  
                     }  
                     catch(InterruptedException success) {  
                     }  
                 }  
             });  
811    
         try {  
812              t.start();              t.start();
813              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
814              t.interrupt();              t.interrupt();
815              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
816              assertFalse(t.isAlive());              assertFalse(t.isAlive());
817          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
818    
819      /**      /**
820       * awaitUntil is interruptible       * awaitUntil is interruptible
821       */       */
822      public void testAwaitUntil_Interrupt() {      public void testAwaitUntil_Interrupt() throws InterruptedException {
823          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
824          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
825          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
826                  public void run() {              public void realRun() throws InterruptedException {
827                      try {                  sync.acquire(1);
                         lock.acquire(1);  
828                          java.util.Date d = new java.util.Date();                          java.util.Date d = new java.util.Date();
829                          c.awaitUntil(new java.util.Date(d.getTime() + 10000));                          c.awaitUntil(new java.util.Date(d.getTime() + 10000));
830                          lock.release(1);              }});
                         threadShouldThrow();  
                     }  
                     catch(InterruptedException success) {  
                     }  
                 }  
             });  
831    
         try {  
832              t.start();              t.start();
833              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
834              t.interrupt();              t.interrupt();
835              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
836              assertFalse(t.isAlive());              assertFalse(t.isAlive());
837          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
838    
839      /**      /**
840       * signalAll wakes up all threads       * signalAll wakes up all threads
841       */       */
842      public void testSignalAll() {      public void testSignalAll() throws InterruptedException {
843          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
844          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
845          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new CheckedRunnable() {
846                  public void run() {              public void realRun() throws InterruptedException {
847                      try {                  sync.acquire(1);
                         lock.acquire(1);  
848                          c.await();                          c.await();
849                          lock.release(1);                  sync.release(1);
850                      }              }});
                     catch(InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
851    
852          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new CheckedRunnable() {
853                  public void run() {              public void realRun() throws InterruptedException {
854                      try {                  sync.acquire(1);
                         lock.acquire(1);  
855                          c.await();                          c.await();
856                          lock.release(1);                  sync.release(1);
857                      }              }});
                     catch(InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
858    
         try {  
859              t1.start();              t1.start();
860              t2.start();              t2.start();
861              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
862              lock.acquire(1);          sync.acquire(1);
863              c.signalAll();              c.signalAll();
864              lock.release(1);          sync.release(1);
865              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
866              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
867              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
868              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
869          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
870    
871    
872      /**      /**
873       * toString indicates current state       * toString indicates current state
874       */       */
875      public void testToString() {      public void testToString() {
876          Mutex lock = new Mutex();          Mutex sync = new Mutex();
877          String us = lock.toString();          String us = sync.toString();
878          assertTrue(us.indexOf("State = 0") >= 0);          assertTrue(us.indexOf("State = 0") >= 0);
879          lock.acquire(1);          sync.acquire(1);
880          String ls = lock.toString();          String ls = sync.toString();
881          assertTrue(ls.indexOf("State = 1") >= 0);          assertTrue(ls.indexOf("State = 1") >= 0);
882      }      }
883    
884      /**      /**
885       * A serialized AQS deserializes with current state       * A serialized AQS deserializes with current state
886       */       */
887      public void testSerialization() {      public void testSerialization() throws Exception {
888          Mutex l = new Mutex();          Mutex l = new Mutex();
889          l.acquire(1);          l.acquire(1);
890          assertTrue(l.isHeldExclusively());          assertTrue(l.isHeldExclusively());
891    
         try {  
892              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
893              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
894              out.writeObject(l);              out.writeObject(l);
# Line 1040  Line 898 
898              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
899              Mutex r = (Mutex) in.readObject();              Mutex r = (Mutex) in.readObject();
900              assertTrue(r.isHeldExclusively());              assertTrue(r.isHeldExclusively());
         } catch(Exception e){  
             e.printStackTrace();  
             unexpectedException();  
         }  
901      }      }
902    
903    
# Line 1058  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 1072  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.tryAcquireSharedNanos(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.tryAcquireSharedNanos(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.tryAcquireSharedNanos(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.16  
changed lines
  Added in v.1.32

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8