[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.17, Mon Jan 12 16:37:40 2004 UTC
# Line 45  Line 45 
45    
46          public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }          public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }
47    
         public void lock() {  
             acquire(1);  
         }  
   
48      }      }
49    
50    
# Line 71  Line 67 
67      /**      /**
68       * A runnable calling acquireInterruptibly       * A runnable calling acquireInterruptibly
69       */       */
70      class InterruptibleLockRunnable implements Runnable {      class InterruptibleSyncRunnable implements Runnable {
71          final Mutex lock;          final Mutex sync;
72          InterruptibleLockRunnable(Mutex l) { lock = l; }          InterruptibleSyncRunnable(Mutex l) { sync = l; }
73          public void run() {          public void run() {
74              try {              try {
75                  lock.acquireInterruptibly(1);                  sync.acquireInterruptibly(1);
76              } catch(InterruptedException success){}              } catch(InterruptedException success){}
77          }          }
78      }      }
# Line 86  Line 82 
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 implements Runnable {
86          final Mutex lock;          final Mutex sync;
87          InterruptedLockRunnable(Mutex l) { lock = l; }          InterruptedSyncRunnable(Mutex l) { sync = l; }
88          public void run() {          public void run() {
89              try {              try {
90                  lock.acquireInterruptibly(1);                  sync.acquireInterruptibly(1);
91                  threadShouldThrow();                  threadShouldThrow();
92              } catch(InterruptedException success){}              } catch(InterruptedException success){}
93          }          }
# Line 106  Line 102 
102      }      }
103    
104      /**      /**
105       * acquiring released lock succeeds       * acquiring released sync succeeds
106       */       */
107      public void testAcquire() {      public void testAcquire() {
108          Mutex rl = new Mutex();          Mutex rl = new Mutex();
109          rl.acquire(1);          rl.acquire(1);
110          assertTrue(rl.isHeldExclusively());          assertTrue(rl.isHeldExclusively());
111          rl.release(1);          rl.release(1);
112            assertFalse(rl.isHeldExclusively());
113      }      }
114    
115      /**      /**
116       * tryAcquire on an released lock succeeds       * tryAcquire on an released sync succeeds
117       */       */
118      public void testTryAcquire() {      public void testTryAcquire() {
119          Mutex rl = new Mutex();          Mutex rl = new Mutex();
# Line 129  Line 126 
126       * hasQueuedThreads reports whether there are waiting threads       * hasQueuedThreads reports whether there are waiting threads
127       */       */
128      public void testhasQueuedThreads() {      public void testhasQueuedThreads() {
129          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
130          Thread t1 = new Thread(new InterruptedLockRunnable(lock));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
131          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
132          try {          try {
133              assertFalse(lock.hasQueuedThreads());              assertFalse(sync.hasQueuedThreads());
134              lock.acquire(1);              sync.acquire(1);
135              t1.start();              t1.start();
136              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
137              assertTrue(lock.hasQueuedThreads());              assertTrue(sync.hasQueuedThreads());
138              t2.start();              t2.start();
139              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
140              assertTrue(lock.hasQueuedThreads());              assertTrue(sync.hasQueuedThreads());
141              t1.interrupt();              t1.interrupt();
142              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
143              assertTrue(lock.hasQueuedThreads());              assertTrue(sync.hasQueuedThreads());
144              lock.release(1);              sync.release(1);
145              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
146              assertFalse(lock.hasQueuedThreads());              assertFalse(sync.hasQueuedThreads());
147              t1.join();              t1.join();
148              t2.join();              t2.join();
149          } catch(Exception e){          } catch(Exception e){
# Line 158  Line 155 
155       * isQueued(null) throws NPE       * isQueued(null) throws NPE
156       */       */
157      public void testIsQueuedNPE() {      public void testIsQueuedNPE() {
158          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
159          try {          try {
160              lock.isQueued(null);              sync.isQueued(null);
161              shouldThrow();              shouldThrow();
162          } catch (NullPointerException success) {          } catch (NullPointerException success) {
163          }          }
# Line 170  Line 167 
167       * isQueued reports whether a thread is queued.       * isQueued reports whether a thread is queued.
168       */       */
169      public void testIsQueued() {      public void testIsQueued() {
170          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
171          Thread t1 = new Thread(new InterruptedLockRunnable(lock));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
172          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
173          try {          try {
174              assertFalse(lock.isQueued(t1));              assertFalse(sync.isQueued(t1));
175              assertFalse(lock.isQueued(t2));              assertFalse(sync.isQueued(t2));
176              lock.acquire(1);              sync.acquire(1);
177              t1.start();              t1.start();
178              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
179              assertTrue(lock.isQueued(t1));              assertTrue(sync.isQueued(t1));
180              t2.start();              t2.start();
181              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
182              assertTrue(lock.isQueued(t1));              assertTrue(sync.isQueued(t1));
183              assertTrue(lock.isQueued(t2));              assertTrue(sync.isQueued(t2));
184              t1.interrupt();              t1.interrupt();
185              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
186              assertFalse(lock.isQueued(t1));              assertFalse(sync.isQueued(t1));
187              assertTrue(lock.isQueued(t2));              assertTrue(sync.isQueued(t2));
188              lock.release(1);              sync.release(1);
189              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
190              assertFalse(lock.isQueued(t1));              assertFalse(sync.isQueued(t1));
191              assertFalse(lock.isQueued(t2));              assertFalse(sync.isQueued(t2));
192              t1.join();              t1.join();
193              t2.join();              t2.join();
194          } catch(Exception e){          } catch(Exception e){
# Line 200  Line 197 
197      }      }
198    
199      /**      /**
200       * getFirstQueuedThread returns first waiting thread or null is none       * getFirstQueuedThread returns first waiting thread or null if none
201       */       */
202      public void testGetFirstQueuedThread() {      public void testGetFirstQueuedThread() {
203          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
204          Thread t1 = new Thread(new InterruptedLockRunnable(lock));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
205          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
206          try {          try {
207              assertNull(lock.getFirstQueuedThread());              assertNull(sync.getFirstQueuedThread());
208              lock.acquire(1);              sync.acquire(1);
209              t1.start();              t1.start();
210              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
211              assertEquals(t1, lock.getFirstQueuedThread());              assertEquals(t1, sync.getFirstQueuedThread());
212              t2.start();              t2.start();
213              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
214              assertEquals(t1, lock.getFirstQueuedThread());              assertEquals(t1, sync.getFirstQueuedThread());
215              t1.interrupt();              t1.interrupt();
216              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
217              assertEquals(t2, lock.getFirstQueuedThread());              assertEquals(t2, sync.getFirstQueuedThread());
218              lock.release(1);              sync.release(1);
219              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
220              assertNull(lock.getFirstQueuedThread());              assertNull(sync.getFirstQueuedThread());
221              t1.join();              t1.join();
222              t2.join();              t2.join();
223          } catch(Exception e){          } catch(Exception e){
# Line 233  Line 230 
230       * hasContended reports false if no thread has ever blocked, else true       * hasContended reports false if no thread has ever blocked, else true
231       */       */
232      public void testHasContended() {      public void testHasContended() {
233          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
234          Thread t1 = new Thread(new InterruptedLockRunnable(lock));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
235          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
236          try {          try {
237              assertFalse(lock.hasContended());              assertFalse(sync.hasContended());
238              lock.acquire(1);              sync.acquire(1);
239                t1.start();
240                Thread.sleep(SHORT_DELAY_MS);
241                assertTrue(sync.hasContended());
242                t2.start();
243                Thread.sleep(SHORT_DELAY_MS);
244                assertTrue(sync.hasContended());
245                t1.interrupt();
246                Thread.sleep(SHORT_DELAY_MS);
247                assertTrue(sync.hasContended());
248                sync.release(1);
249                Thread.sleep(SHORT_DELAY_MS);
250                assertTrue(sync.hasContended());
251                t1.join();
252                t2.join();
253            } catch(Exception e){
254                unexpectedException();
255            }
256        }
257    
258        /**
259         * getQueuedThreads includes waiting threads
260         */
261        public void testGetQueuedThreads() {
262            final Mutex sync = new Mutex();
263            Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
264            Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
265            try {
266                assertTrue(sync.getQueuedThreads().isEmpty());
267                sync.acquire(1);
268                assertTrue(sync.getQueuedThreads().isEmpty());
269                t1.start();
270                Thread.sleep(SHORT_DELAY_MS);
271                assertTrue(sync.getQueuedThreads().contains(t1));
272                t2.start();
273                Thread.sleep(SHORT_DELAY_MS);
274                assertTrue(sync.getQueuedThreads().contains(t1));
275                assertTrue(sync.getQueuedThreads().contains(t2));
276                t1.interrupt();
277                Thread.sleep(SHORT_DELAY_MS);
278                assertFalse(sync.getQueuedThreads().contains(t1));
279                assertTrue(sync.getQueuedThreads().contains(t2));
280                sync.release(1);
281                Thread.sleep(SHORT_DELAY_MS);
282                assertTrue(sync.getQueuedThreads().isEmpty());
283                t1.join();
284                t2.join();
285            } catch(Exception e){
286                unexpectedException();
287            }
288        }
289    
290        /**
291         * getExclusiveQueuedThreads includes waiting threads
292         */
293        public void testGetExclusiveQueuedThreads() {
294            final Mutex sync = new Mutex();
295            Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
296            Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
297            try {
298                assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
299                sync.acquire(1);
300                assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
301                t1.start();
302                Thread.sleep(SHORT_DELAY_MS);
303                assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
304                t2.start();
305                Thread.sleep(SHORT_DELAY_MS);
306                assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
307                assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
308                t1.interrupt();
309                Thread.sleep(SHORT_DELAY_MS);
310                assertFalse(sync.getExclusiveQueuedThreads().contains(t1));
311                assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
312                sync.release(1);
313                Thread.sleep(SHORT_DELAY_MS);
314                assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
315                t1.join();
316                t2.join();
317            } catch(Exception e){
318                unexpectedException();
319            }
320        }
321    
322        /**
323         * getSharedQueuedThreads does not include exclusively waiting threads
324         */
325        public void testGetSharedQueuedThreads() {
326            final Mutex sync = new Mutex();
327            Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
328            Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
329            try {
330                assertTrue(sync.getSharedQueuedThreads().isEmpty());
331                sync.acquire(1);
332                assertTrue(sync.getSharedQueuedThreads().isEmpty());
333              t1.start();              t1.start();
334              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
335              assertTrue(lock.hasContended());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
336              t2.start();              t2.start();
337              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
338              assertTrue(lock.hasContended());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
339              t1.interrupt();              t1.interrupt();
340              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
341              assertTrue(lock.hasContended());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
342              lock.release(1);              sync.release(1);
343              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
344              assertTrue(lock.hasContended());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
345              t1.join();              t1.join();
346              t2.join();              t2.join();
347          } catch(Exception e){          } catch(Exception e){
# Line 262  Line 353 
353       * tryAcquireNanos is interruptible.       * tryAcquireNanos is interruptible.
354       */       */
355      public void testInterruptedException2() {      public void testInterruptedException2() {
356          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
357          lock.acquire(1);          sync.acquire(1);
358          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
359                  public void run() {                  public void run() {
360                      try {                      try {
361                          lock.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);                          sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
362                          threadShouldThrow();                          threadShouldThrow();
363                      } catch(InterruptedException success){}                      } catch(InterruptedException success){}
364                  }                  }
# Line 282  Line 373 
373    
374    
375      /**      /**
376       * TryAcquire on a locked lock fails       * TryAcquire on exclusively held sync fails
377       */       */
378      public void testTryAcquireWhenLocked() {      public void testTryAcquireWhenSynced() {
379          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
380          lock.acquire(1);          sync.acquire(1);
381          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
382                  public void run() {                  public void run() {
383                      threadAssertFalse(lock.tryAcquire(1));                      threadAssertFalse(sync.tryAcquire(1));
384                  }                  }
385              });              });
386          try {          try {
387              t.start();              t.start();
388              t.join();              t.join();
389              lock.release(1);              sync.release(1);
390          } catch(Exception e){          } catch(Exception e){
391              unexpectedException();              unexpectedException();
392          }          }
393      }      }
394    
395      /**      /**
396       * tryAcquireNanos on a locked lock times out       * tryAcquireNanos on an exclusively held sync times out
397       */       */
398      public void testAcquireNanos_Timeout() {      public void testAcquireNanos_Timeout() {
399          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
400          lock.acquire(1);          sync.acquire(1);
401          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
402                  public void run() {                  public void run() {
403                      try {                      try {
404                          threadAssertFalse(lock.tryAcquireNanos(1, 1000 * 1000));                          threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000));
405                      } catch (Exception ex) {                      } catch (Exception ex) {
406                          threadUnexpectedException();                          threadUnexpectedException();
407                      }                      }
# Line 319  Line 410 
410          try {          try {
411              t.start();              t.start();
412              t.join();              t.join();
413              lock.release(1);              sync.release(1);
414          } catch(Exception e){          } catch(Exception e){
415              unexpectedException();              unexpectedException();
416          }          }
# Line 330  Line 421 
421       * getState is true when acquired and false when not       * getState is true when acquired and false when not
422       */       */
423      public void testGetState() {      public void testGetState() {
424          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
425          lock.acquire(1);          sync.acquire(1);
426          assertTrue(lock.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
427          lock.release(1);          sync.release(1);
428          assertFalse(lock.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
429          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
430                  public void run() {                  public void run() {
431                      lock.acquire(1);                      sync.acquire(1);
432                      try {                      try {
433                          Thread.sleep(SMALL_DELAY_MS);                          Thread.sleep(SMALL_DELAY_MS);
434                      }                      }
435                      catch(Exception e) {                      catch(Exception e) {
436                          threadUnexpectedException();                          threadUnexpectedException();
437                      }                      }
438                      lock.release(1);                      sync.release(1);
439                  }                  }
440              });              });
441          try {          try {
442              t.start();              t.start();
443              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
444              assertTrue(lock.isHeldExclusively());              assertTrue(sync.isHeldExclusively());
445              t.join();              t.join();
446              assertFalse(lock.isHeldExclusively());              assertFalse(sync.isHeldExclusively());
447          } catch(Exception e){          } catch(Exception e){
448              unexpectedException();              unexpectedException();
449          }          }
# Line 363  Line 454 
454       * acquireInterruptibly is interruptible.       * acquireInterruptibly is interruptible.
455       */       */
456      public void testAcquireInterruptibly1() {      public void testAcquireInterruptibly1() {
457          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
458          lock.acquire(1);          sync.acquire(1);
459          Thread t = new Thread(new InterruptedLockRunnable(lock));          Thread t = new Thread(new InterruptedSyncRunnable(sync));
460          try {          try {
461              t.start();              t.start();
462              t.interrupt();              t.interrupt();
463              lock.release(1);              sync.release(1);
464              t.join();              t.join();
465          } catch(Exception e){          } catch(Exception e){
466              unexpectedException();              unexpectedException();
# Line 380  Line 471 
471       * acquireInterruptibly succeeds when released, else is interruptible       * acquireInterruptibly succeeds when released, else is interruptible
472       */       */
473      public void testAcquireInterruptibly2() {      public void testAcquireInterruptibly2() {
474          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
475          try {          try {
476              lock.acquireInterruptibly(1);              sync.acquireInterruptibly(1);
477          } catch(Exception e) {          } catch(Exception e) {
478              unexpectedException();              unexpectedException();
479          }          }
480          Thread t = new Thread(new InterruptedLockRunnable(lock));          Thread t = new Thread(new InterruptedSyncRunnable(sync));
481          try {          try {
482              t.start();              t.start();
483              t.interrupt();              t.interrupt();
484              assertTrue(lock.isHeldExclusively());              assertTrue(sync.isHeldExclusively());
485              t.join();              t.join();
486          } catch(Exception e){          } catch(Exception e){
487              unexpectedException();              unexpectedException();
# Line 398  Line 489 
489      }      }
490    
491      /**      /**
492       * owns is true for a condition created by lock else false       * owns is true for a condition created by sync else false
493       */       */
494      public void testOwns() {      public void testOwns() {
495          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
496          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
497          final Mutex lock2 = new Mutex();          final Mutex sync2 = new Mutex();
498          assertTrue(lock.owns(c));          assertTrue(sync.owns(c));
499          assertFalse(lock2.owns(c));          assertFalse(sync2.owns(c));
500      }      }
501    
502      /**      /**
503       * Calling await without holding lock throws IllegalMonitorStateException       * Calling await without holding sync throws IllegalMonitorStateException
504       */       */
505      public void testAwait_IllegalMonitor() {      public void testAwait_IllegalMonitor() {
506          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
507          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
508          try {          try {
509              c.await();              c.await();
510              shouldThrow();              shouldThrow();
# Line 426  Line 517 
517      }      }
518    
519      /**      /**
520       * Calling signal without holding lock throws IllegalMonitorStateException       * Calling signal without holding sync throws IllegalMonitorStateException
521       */       */
522      public void testSignal_IllegalMonitor() {      public void testSignal_IllegalMonitor() {
523          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
524          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
525          try {          try {
526              c.signal();              c.signal();
527              shouldThrow();              shouldThrow();
# Line 446  Line 537 
537       * awaitNanos without a signal times out       * awaitNanos without a signal times out
538       */       */
539      public void testAwaitNanos_Timeout() {      public void testAwaitNanos_Timeout() {
540          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
541          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
542          try {          try {
543              lock.acquire(1);              sync.acquire(1);
544              long t = c.awaitNanos(100);              long t = c.awaitNanos(100);
545              assertTrue(t <= 0);              assertTrue(t <= 0);
546              lock.release(1);              sync.release(1);
547          }          }
548          catch (Exception ex) {          catch (Exception ex) {
549              unexpectedException();              unexpectedException();
# Line 460  Line 551 
551      }      }
552    
553      /**      /**
554       *  timed await without a signal times out       *  Timed await without a signal times out
555       */       */
556      public void testAwait_Timeout() {      public void testAwait_Timeout() {
557          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
558          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
559          try {          try {
560              lock.acquire(1);              sync.acquire(1);
561              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
562              lock.release(1);              sync.release(1);
563          }          }
564          catch (Exception ex) {          catch (Exception ex) {
565              unexpectedException();              unexpectedException();
# Line 479  Line 570 
570       * awaitUntil without a signal times out       * awaitUntil without a signal times out
571       */       */
572      public void testAwaitUntil_Timeout() {      public void testAwaitUntil_Timeout() {
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.acquire(1);              sync.acquire(1);
577              java.util.Date d = new java.util.Date();              java.util.Date d = new java.util.Date();
578              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
579              lock.release(1);              sync.release(1);
580          }          }
581          catch (Exception ex) {          catch (Exception ex) {
582              unexpectedException();              unexpectedException();
# Line 496  Line 587 
587       * await returns when signalled       * await returns when signalled
588       */       */
589      public void testAwait() {      public void testAwait() {
590          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
591          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
592          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
593                  public void run() {                  public void run() {
594                      try {                      try {
595                          lock.acquire(1);                          sync.acquire(1);
596                          c.await();                          c.await();
597                          lock.release(1);                          sync.release(1);
598                      }                      }
599                      catch(InterruptedException e) {                      catch(InterruptedException e) {
600                          threadUnexpectedException();                          threadUnexpectedException();
# Line 514  Line 605 
605          try {          try {
606              t.start();              t.start();
607              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
608              lock.acquire(1);              sync.acquire(1);
609              c.signal();              c.signal();
610              lock.release(1);              sync.release(1);
611              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
612              assertFalse(t.isAlive());              assertFalse(t.isAlive());
613          }          }
# Line 531  Line 622 
622       * hasWaiters throws NPE if null       * hasWaiters throws NPE if null
623       */       */
624      public void testHasWaitersNPE() {      public void testHasWaitersNPE() {
625          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
626          try {          try {
627              lock.hasWaiters(null);              sync.hasWaiters(null);
628              shouldThrow();              shouldThrow();
629          } catch (NullPointerException success) {          } catch (NullPointerException success) {
630          } catch (Exception ex) {          } catch (Exception ex) {
# Line 545  Line 636 
636       * getWaitQueueLength throws NPE if null       * getWaitQueueLength throws NPE if null
637       */       */
638      public void testGetWaitQueueLengthNPE() {      public void testGetWaitQueueLengthNPE() {
639          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
640          try {          try {
641              lock.getWaitQueueLength(null);              sync.getWaitQueueLength(null);
642              shouldThrow();              shouldThrow();
643          } catch (NullPointerException success) {          } catch (NullPointerException success) {
644          } catch (Exception ex) {          } catch (Exception ex) {
# Line 560  Line 651 
651       * getWaitingThreads throws NPE if null       * getWaitingThreads throws NPE if null
652       */       */
653      public void testGetWaitingThreadsNPE() {      public void testGetWaitingThreadsNPE() {
654          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
655          try {          try {
656              lock.getWaitingThreads(null);              sync.getWaitingThreads(null);
657              shouldThrow();              shouldThrow();
658          } catch (NullPointerException success) {          } catch (NullPointerException success) {
659          } catch (Exception ex) {          } catch (Exception ex) {
# Line 575  Line 666 
666       * hasWaiters throws IAE if not owned       * hasWaiters throws IAE if not owned
667       */       */
668      public void testHasWaitersIAE() {      public void testHasWaitersIAE() {
669          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
670          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition());
671          final Mutex lock2 = new Mutex();          final Mutex sync2 = new Mutex();
672          try {          try {
673              lock2.hasWaiters(c);              sync2.hasWaiters(c);
674              shouldThrow();              shouldThrow();
675          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {
676          } catch (Exception ex) {          } catch (Exception ex) {
# Line 588  Line 679 
679      }      }
680    
681      /**      /**
682       * hasWaiters throws IMSE if not locked       * hasWaiters throws IMSE if not synced
683       */       */
684      public void testHasWaitersIMSE() {      public void testHasWaitersIMSE() {
685          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
686          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition());
687          try {          try {
688              lock.hasWaiters(c);              sync.hasWaiters(c);
689              shouldThrow();              shouldThrow();
690          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {
691          } catch (Exception ex) {          } catch (Exception ex) {
# Line 607  Line 698 
698       * getWaitQueueLength throws IAE if not owned       * getWaitQueueLength throws IAE if not owned
699       */       */
700      public void testGetWaitQueueLengthIAE() {      public void testGetWaitQueueLengthIAE() {
701          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
702          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition());
703          final Mutex lock2 = new Mutex();          final Mutex sync2 = new Mutex();
704          try {          try {
705              lock2.getWaitQueueLength(c);              sync2.getWaitQueueLength(c);
706              shouldThrow();              shouldThrow();
707          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {
708          } catch (Exception ex) {          } catch (Exception ex) {
# Line 620  Line 711 
711      }      }
712    
713      /**      /**
714       * getWaitQueueLength throws IMSE if not locked       * getWaitQueueLength throws IMSE if not synced
715       */       */
716      public void testGetWaitQueueLengthIMSE() {      public void testGetWaitQueueLengthIMSE() {
717          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
718          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition());
719          try {          try {
720              lock.getWaitQueueLength(c);              sync.getWaitQueueLength(c);
721              shouldThrow();              shouldThrow();
722          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {
723          } catch (Exception ex) {          } catch (Exception ex) {
# Line 639  Line 730 
730       * getWaitingThreads throws IAE if not owned       * getWaitingThreads throws IAE if not owned
731       */       */
732      public void testGetWaitingThreadsIAE() {      public void testGetWaitingThreadsIAE() {
733          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
734          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition());
735          final Mutex lock2 = new Mutex();          final Mutex sync2 = new Mutex();
736          try {          try {
737              lock2.getWaitingThreads(c);              sync2.getWaitingThreads(c);
738              shouldThrow();              shouldThrow();
739          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {
740          } catch (Exception ex) {          } catch (Exception ex) {
# Line 652  Line 743 
743      }      }
744    
745      /**      /**
746       * getWaitingThreads throws IMSE if not locked       * getWaitingThreads throws IMSE if not synced
747       */       */
748      public void testGetWaitingThreadsIMSE() {      public void testGetWaitingThreadsIMSE() {
749          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
750          final AbstractQueuedSynchronizer.ConditionObject c = (lock.newCondition());          final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition());
751          try {          try {
752              lock.getWaitingThreads(c);              sync.getWaitingThreads(c);
753              shouldThrow();              shouldThrow();
754          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {
755          } catch (Exception ex) {          } catch (Exception ex) {
# Line 672  Line 763 
763       * hasWaiters returns true when a thread is waiting, else false       * hasWaiters returns true when a thread is waiting, else false
764       */       */
765      public void testHasWaiters() {      public void testHasWaiters() {
766          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
767          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
768          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
769                  public void run() {                  public void run() {
770                      try {                      try {
771                          lock.acquire(1);                          sync.acquire(1);
772                          threadAssertFalse(lock.hasWaiters(c));                          threadAssertFalse(sync.hasWaiters(c));
773                          threadAssertEquals(0, lock.getWaitQueueLength(c));                          threadAssertEquals(0, sync.getWaitQueueLength(c));
774                          c.await();                          c.await();
775                          lock.release(1);                          sync.release(1);
776                      }                      }
777                      catch(InterruptedException e) {                      catch(InterruptedException e) {
778                          threadUnexpectedException();                          threadUnexpectedException();
# Line 692  Line 783 
783          try {          try {
784              t.start();              t.start();
785              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
786              lock.acquire(1);              sync.acquire(1);
787              assertTrue(lock.hasWaiters(c));              assertTrue(sync.hasWaiters(c));
788              assertEquals(1, lock.getWaitQueueLength(c));              assertEquals(1, sync.getWaitQueueLength(c));
789              c.signal();              c.signal();
790              lock.release(1);              sync.release(1);
791              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
792              lock.acquire(1);              sync.acquire(1);
793              assertFalse(lock.hasWaiters(c));              assertFalse(sync.hasWaiters(c));
794              assertEquals(0, lock.getWaitQueueLength(c));              assertEquals(0, sync.getWaitQueueLength(c));
795              lock.release(1);              sync.release(1);
796              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
797              assertFalse(t.isAlive());              assertFalse(t.isAlive());
798          }          }
# Line 714  Line 805 
805       * getWaitQueueLength returns number of waiting threads       * getWaitQueueLength returns number of waiting threads
806       */       */
807      public void testGetWaitQueueLength() {      public void testGetWaitQueueLength() {
808          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
809          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
810          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
811                  public void run() {                  public void run() {
812                      try {                      try {
813                          lock.acquire(1);                          sync.acquire(1);
814                          threadAssertFalse(lock.hasWaiters(c));                          threadAssertFalse(sync.hasWaiters(c));
815                          threadAssertEquals(0, lock.getWaitQueueLength(c));                          threadAssertEquals(0, sync.getWaitQueueLength(c));
816                          c.await();                          c.await();
817                          lock.release(1);                          sync.release(1);
818                      }                      }
819                      catch(InterruptedException e) {                      catch(InterruptedException e) {
820                          threadUnexpectedException();                          threadUnexpectedException();
# Line 734  Line 825 
825          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new Runnable() {
826                  public void run() {                  public void run() {
827                      try {                      try {
828                          lock.acquire(1);                          sync.acquire(1);
829                          threadAssertTrue(lock.hasWaiters(c));                          threadAssertTrue(sync.hasWaiters(c));
830                          threadAssertEquals(1, lock.getWaitQueueLength(c));                          threadAssertEquals(1, sync.getWaitQueueLength(c));
831                          c.await();                          c.await();
832                          lock.release(1);                          sync.release(1);
833                      }                      }
834                      catch(InterruptedException e) {                      catch(InterruptedException e) {
835                          threadUnexpectedException();                          threadUnexpectedException();
# Line 751  Line 842 
842              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
843              t2.start();              t2.start();
844              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
845              lock.acquire(1);              sync.acquire(1);
846              assertTrue(lock.hasWaiters(c));              assertTrue(sync.hasWaiters(c));
847              assertEquals(2, lock.getWaitQueueLength(c));              assertEquals(2, sync.getWaitQueueLength(c));
848              c.signalAll();              c.signalAll();
849              lock.release(1);              sync.release(1);
850              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
851              lock.acquire(1);              sync.acquire(1);
852              assertFalse(lock.hasWaiters(c));              assertFalse(sync.hasWaiters(c));
853              assertEquals(0, lock.getWaitQueueLength(c));              assertEquals(0, sync.getWaitQueueLength(c));
854              lock.release(1);              sync.release(1);
855              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
856              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
857              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
# Line 775  Line 866 
866       * getWaitingThreads returns only and all waiting threads       * getWaitingThreads returns only and all waiting threads
867       */       */
868      public void testGetWaitingThreads() {      public void testGetWaitingThreads() {
869          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
870          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
871          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
872                  public void run() {                  public void run() {
873                      try {                      try {
874                          lock.acquire(1);                          sync.acquire(1);
875                          threadAssertTrue(lock.getWaitingThreads(c).isEmpty());                          threadAssertTrue(sync.getWaitingThreads(c).isEmpty());
876                          c.await();                          c.await();
877                          lock.release(1);                          sync.release(1);
878                      }                      }
879                      catch(InterruptedException e) {                      catch(InterruptedException e) {
880                          threadUnexpectedException();                          threadUnexpectedException();
# Line 794  Line 885 
885          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new Runnable() {
886                  public void run() {                  public void run() {
887                      try {                      try {
888                          lock.acquire(1);                          sync.acquire(1);
889                          threadAssertFalse(lock.getWaitingThreads(c).isEmpty());                          threadAssertFalse(sync.getWaitingThreads(c).isEmpty());
890                          c.await();                          c.await();
891                          lock.release(1);                          sync.release(1);
892                      }                      }
893                      catch(InterruptedException e) {                      catch(InterruptedException e) {
894                          threadUnexpectedException();                          threadUnexpectedException();
# Line 806  Line 897 
897              });              });
898    
899          try {          try {
900              lock.acquire(1);              sync.acquire(1);
901              assertTrue(lock.getWaitingThreads(c).isEmpty());              assertTrue(sync.getWaitingThreads(c).isEmpty());
902              lock.release(1);              sync.release(1);
903              t1.start();              t1.start();
904              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
905              t2.start();              t2.start();
906              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
907              lock.acquire(1);              sync.acquire(1);
908              assertTrue(lock.hasWaiters(c));              assertTrue(sync.hasWaiters(c));
909              assertTrue(lock.getWaitingThreads(c).contains(t1));              assertTrue(sync.getWaitingThreads(c).contains(t1));
910              assertTrue(lock.getWaitingThreads(c).contains(t2));              assertTrue(sync.getWaitingThreads(c).contains(t2));
911              c.signalAll();              c.signalAll();
912              lock.release(1);              sync.release(1);
913              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
914              lock.acquire(1);              sync.acquire(1);
915              assertFalse(lock.hasWaiters(c));              assertFalse(sync.hasWaiters(c));
916              assertTrue(lock.getWaitingThreads(c).isEmpty());              assertTrue(sync.getWaitingThreads(c).isEmpty());
917              lock.release(1);              sync.release(1);
918              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
919              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
920              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
# Line 840  Line 931 
931       * awaitUninterruptibly doesn't abort on interrupt       * awaitUninterruptibly doesn't abort on interrupt
932       */       */
933      public void testAwaitUninterruptibly() {      public void testAwaitUninterruptibly() {
934          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
935          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
936          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
937                  public void run() {                  public void run() {
938                      lock.acquire(1);                      sync.acquire(1);
939                      c.awaitUninterruptibly();                      c.awaitUninterruptibly();
940                      lock.release(1);                      sync.release(1);
941                  }                  }
942              });              });
943    
# Line 854  Line 945 
945              t.start();              t.start();
946              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
947              t.interrupt();              t.interrupt();
948              lock.acquire(1);              sync.acquire(1);
949              c.signal();              c.signal();
950              lock.release(1);              sync.release(1);
951              assert(t.isInterrupted());              assert(t.isInterrupted());
952              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
953              assertFalse(t.isAlive());              assertFalse(t.isAlive());
# Line 870  Line 961 
961       * await is interruptible       * await is interruptible
962       */       */
963      public void testAwait_Interrupt() {      public void testAwait_Interrupt() {
964          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
965          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
966          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
967                  public void run() {                  public void run() {
968                      try {                      try {
969                          lock.acquire(1);                          sync.acquire(1);
970                          c.await();                          c.await();
971                          lock.release(1);                          sync.release(1);
972                          threadShouldThrow();                          threadShouldThrow();
973                      }                      }
974                      catch(InterruptedException success) {                      catch(InterruptedException success) {
# Line 901  Line 992 
992       * awaitNanos is interruptible       * awaitNanos is interruptible
993       */       */
994      public void testAwaitNanos_Interrupt() {      public void testAwaitNanos_Interrupt() {
995          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
996          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
997          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
998                  public void run() {                  public void run() {
999                      try {                      try {
1000                          lock.acquire(1);                          sync.acquire(1);
1001                          c.awaitNanos(1000 * 1000 * 1000); // 1 sec                          c.awaitNanos(1000 * 1000 * 1000); // 1 sec
1002                          lock.release(1);                          sync.release(1);
1003                          threadShouldThrow();                          threadShouldThrow();
1004                      }                      }
1005                      catch(InterruptedException success) {                      catch(InterruptedException success) {
# Line 932  Line 1023 
1023       * awaitUntil is interruptible       * awaitUntil is interruptible
1024       */       */
1025      public void testAwaitUntil_Interrupt() {      public void testAwaitUntil_Interrupt() {
1026          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
1027          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
1028          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
1029                  public void run() {                  public void run() {
1030                      try {                      try {
1031                          lock.acquire(1);                          sync.acquire(1);
1032                          java.util.Date d = new java.util.Date();                          java.util.Date d = new java.util.Date();
1033                          c.awaitUntil(new java.util.Date(d.getTime() + 10000));                          c.awaitUntil(new java.util.Date(d.getTime() + 10000));
1034                          lock.release(1);                          sync.release(1);
1035                          threadShouldThrow();                          threadShouldThrow();
1036                      }                      }
1037                      catch(InterruptedException success) {                      catch(InterruptedException success) {
# Line 964  Line 1055 
1055       * signalAll wakes up all threads       * signalAll wakes up all threads
1056       */       */
1057      public void testSignalAll() {      public void testSignalAll() {
1058          final Mutex lock = new Mutex();          final Mutex sync = new Mutex();
1059          final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
1060          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
1061                  public void run() {                  public void run() {
1062                      try {                      try {
1063                          lock.acquire(1);                          sync.acquire(1);
1064                          c.await();                          c.await();
1065                          lock.release(1);                          sync.release(1);
1066                      }                      }
1067                      catch(InterruptedException e) {                      catch(InterruptedException e) {
1068                          threadUnexpectedException();                          threadUnexpectedException();
# Line 982  Line 1073 
1073          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new Runnable() {
1074                  public void run() {                  public void run() {
1075                      try {                      try {
1076                          lock.acquire(1);                          sync.acquire(1);
1077                          c.await();                          c.await();
1078                          lock.release(1);                          sync.release(1);
1079                      }                      }
1080                      catch(InterruptedException e) {                      catch(InterruptedException e) {
1081                          threadUnexpectedException();                          threadUnexpectedException();
# Line 996  Line 1087 
1087              t1.start();              t1.start();
1088              t2.start();              t2.start();
1089              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1090              lock.acquire(1);              sync.acquire(1);
1091              c.signalAll();              c.signalAll();
1092              lock.release(1);              sync.release(1);
1093              t1.join(SHORT_DELAY_MS);              t1.join(SHORT_DELAY_MS);
1094              t2.join(SHORT_DELAY_MS);              t2.join(SHORT_DELAY_MS);
1095              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
# Line 1014  Line 1105 
1105       * toString indicates current state       * toString indicates current state
1106       */       */
1107      public void testToString() {      public void testToString() {
1108          Mutex lock = new Mutex();          Mutex sync = new Mutex();
1109          String us = lock.toString();          String us = sync.toString();
1110          assertTrue(us.indexOf("State = 0") >= 0);          assertTrue(us.indexOf("State = 0") >= 0);
1111          lock.acquire(1);          sync.acquire(1);
1112          String ls = lock.toString();          String ls = sync.toString();
1113          assertTrue(ls.indexOf("State = 1") >= 0);          assertTrue(ls.indexOf("State = 1") >= 0);
1114      }      }
1115    
# Line 1058  Line 1149 
1149      }      }
1150    
1151      /**      /**
1152       * release and has no effect when already signalled       * releaseShared has no effect when already signalled
1153       */       */
1154      public void testReleaseShared() {      public void testReleaseShared() {
1155          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();

Legend:
Removed from v.1.16  
changed lines
  Added in v.1.17

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8