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

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

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

revision 1.8, Tue Nov 17 13:40:14 2009 UTC revision 1.9, Wed Nov 18 08:22:57 2009 UTC
# Line 128  Line 128 
128      /**      /**
129       * hasQueuedThreads reports whether there are waiting threads       * hasQueuedThreads reports whether there are waiting threads
130       */       */
131      public void testhasQueuedThreads() {      public void testhasQueuedThreads() throws InterruptedException {
132          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
133          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
134          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
135              assertFalse(sync.hasQueuedThreads());              assertFalse(sync.hasQueuedThreads());
136              sync.acquire(1);              sync.acquire(1);
137              t1.start();              t1.start();
# Line 149  Line 148 
148              assertFalse(sync.hasQueuedThreads());              assertFalse(sync.hasQueuedThreads());
149              t1.join();              t1.join();
150              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
151      }      }
152    
153      /**      /**
# Line 162  Line 158 
158          try {          try {
159              sync.isQueued(null);              sync.isQueued(null);
160              shouldThrow();              shouldThrow();
161          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         }  
162      }      }
163    
164      /**      /**
165       * isQueued reports whether a thread is queued.       * isQueued reports whether a thread is queued.
166       */       */
167      public void testIsQueued() {      public void testIsQueued() throws InterruptedException {
168          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
169          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
170          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
171              assertFalse(sync.isQueued(t1));              assertFalse(sync.isQueued(t1));
172              assertFalse(sync.isQueued(t2));              assertFalse(sync.isQueued(t2));
173              sync.acquire(1);              sync.acquire(1);
# Line 195  Line 189 
189              assertFalse(sync.isQueued(t2));              assertFalse(sync.isQueued(t2));
190              t1.join();              t1.join();
191              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
192      }      }
193    
194      /**      /**
195       * getFirstQueuedThread returns first waiting thread or null if none       * getFirstQueuedThread returns first waiting thread or null if none
196       */       */
197      public void testGetFirstQueuedThread() {      public void testGetFirstQueuedThread() throws InterruptedException {
198          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
199          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
200          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
201              assertNull(sync.getFirstQueuedThread());              assertNull(sync.getFirstQueuedThread());
202              sync.acquire(1);              sync.acquire(1);
203              t1.start();              t1.start();
# Line 225  Line 215 
215              assertNull(sync.getFirstQueuedThread());              assertNull(sync.getFirstQueuedThread());
216              t1.join();              t1.join();
217              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
218      }      }
219    
220    
221      /**      /**
222       * hasContended reports false if no thread has ever blocked, else true       * hasContended reports false if no thread has ever blocked, else true
223       */       */
224      public void testHasContended() {      public void testHasContended() throws InterruptedException {
225          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
226          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
227          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
228              assertFalse(sync.hasContended());              assertFalse(sync.hasContended());
229              sync.acquire(1);              sync.acquire(1);
230              t1.start();              t1.start();
# Line 255  Line 241 
241              assertTrue(sync.hasContended());              assertTrue(sync.hasContended());
242              t1.join();              t1.join();
243              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
244      }      }
245    
246      /**      /**
247       * getQueuedThreads includes waiting threads       * getQueuedThreads includes waiting threads
248       */       */
249      public void testGetQueuedThreads() {      public void testGetQueuedThreads() throws InterruptedException {
250          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
251          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
252          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
253              assertTrue(sync.getQueuedThreads().isEmpty());              assertTrue(sync.getQueuedThreads().isEmpty());
254              sync.acquire(1);              sync.acquire(1);
255              assertTrue(sync.getQueuedThreads().isEmpty());              assertTrue(sync.getQueuedThreads().isEmpty());
# Line 287  Line 269 
269              assertTrue(sync.getQueuedThreads().isEmpty());              assertTrue(sync.getQueuedThreads().isEmpty());
270              t1.join();              t1.join();
271              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
272      }      }
273    
274      /**      /**
275       * getExclusiveQueuedThreads includes waiting threads       * getExclusiveQueuedThreads includes waiting threads
276       */       */
277      public void testGetExclusiveQueuedThreads() {      public void testGetExclusiveQueuedThreads() throws InterruptedException {
278          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
279          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
280          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
281              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
282              sync.acquire(1);              sync.acquire(1);
283              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
# Line 319  Line 297 
297              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
298              t1.join();              t1.join();
299              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
300      }      }
301    
302      /**      /**
303       * getSharedQueuedThreads does not include exclusively waiting threads       * getSharedQueuedThreads does not include exclusively waiting threads
304       */       */
305      public void testGetSharedQueuedThreads() {      public void testGetSharedQueuedThreads() throws InterruptedException {
306          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
307          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
308          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
309              assertTrue(sync.getSharedQueuedThreads().isEmpty());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
310              sync.acquire(1);              sync.acquire(1);
311              assertTrue(sync.getSharedQueuedThreads().isEmpty());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
# Line 349  Line 323 
323              assertTrue(sync.getSharedQueuedThreads().isEmpty());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
324              t1.join();              t1.join();
325              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
326      }      }
327    
328      /**      /**
329       * tryAcquireNanos is interruptible.       * tryAcquireNanos is interruptible.
330       */       */
331      public void testInterruptedException2() {      public void testInterruptedException2() throws InterruptedException {
332          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
333          sync.acquire(1);          sync.acquire(1);
334          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 368  Line 339 
339                      } catch (InterruptedException success) {}                      } catch (InterruptedException success) {}
340                  }                  }
341              });              });
342          try {  
343              t.start();              t.start();
344              t.interrupt();              t.interrupt();
345          } catch (Exception e) {          t.join();
             unexpectedException();  
         }  
346      }      }
347    
348    
349      /**      /**
350       * TryAcquire on exclusively held sync fails       * TryAcquire on exclusively held sync fails
351       */       */
352      public void testTryAcquireWhenSynced() {      public void testTryAcquireWhenSynced() throws InterruptedException {
353          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
354          sync.acquire(1);          sync.acquire(1);
355          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 388  Line 357 
357                      threadAssertFalse(sync.tryAcquire(1));                      threadAssertFalse(sync.tryAcquire(1));
358                  }                  }
359              });              });
360          try {  
361              t.start();              t.start();
362              t.join();              t.join();
363              sync.release(1);              sync.release(1);
         } catch (Exception e) {  
             unexpectedException();  
         }  
364      }      }
365    
366      /**      /**
367       * tryAcquireNanos on an exclusively held sync times out       * tryAcquireNanos on an exclusively held sync times out
368       */       */
369      public void testAcquireNanos_Timeout() {      public void testAcquireNanos_Timeout() throws InterruptedException {
370          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
371          sync.acquire(1);          sync.acquire(1);
372          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 412  Line 378 
378                      }                      }
379                  }                  }
380              });              });
381          try {  
382              t.start();              t.start();
383              t.join();              t.join();
384              sync.release(1);              sync.release(1);
         } catch (Exception e) {  
             unexpectedException();  
         }  
385      }      }
386    
387    
388      /**      /**
389       * getState is true when acquired and false when not       * getState is true when acquired and false when not
390       */       */
391      public void testGetState() {      public void testGetState() throws InterruptedException {
392          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
393          sync.acquire(1);          sync.acquire(1);
394          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
# Line 443  Line 406 
406                      sync.release(1);                      sync.release(1);
407                  }                  }
408              });              });
409          try {  
410              t.start();              t.start();
411              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
412              assertTrue(sync.isHeldExclusively());              assertTrue(sync.isHeldExclusively());
413              t.join();              t.join();
414              assertFalse(sync.isHeldExclusively());              assertFalse(sync.isHeldExclusively());
         } catch (Exception e) {  
             unexpectedException();  
         }  
415      }      }
416    
417    
418      /**      /**
419       * acquireInterruptibly is interruptible.       * acquireInterruptibly is interruptible.
420       */       */
421      public void testAcquireInterruptibly1() {      public void testAcquireInterruptibly1() throws InterruptedException {
422          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
423          sync.acquire(1);          sync.acquire(1);
424          Thread t = new Thread(new InterruptedSyncRunnable(sync));          Thread t = new Thread(new InterruptedSyncRunnable(sync));
         try {  
425              t.start();              t.start();
426              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
427              t.interrupt();              t.interrupt();
428              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
429              sync.release(1);              sync.release(1);
430              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
431      }      }
432    
433      /**      /**
434       * acquireInterruptibly succeeds when released, else is interruptible       * acquireInterruptibly succeeds when released, else is interruptible
435       */       */
436      public void testAcquireInterruptibly2() {      public void testAcquireInterruptibly2() throws InterruptedException {
437          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         try {  
438              sync.acquireInterruptibly(1);              sync.acquireInterruptibly(1);
         } catch (Exception e) {  
             unexpectedException();  
         }  
439          Thread t = new Thread(new InterruptedSyncRunnable(sync));          Thread t = new Thread(new InterruptedSyncRunnable(sync));
         try {  
440              t.start();              t.start();
441              t.interrupt();              t.interrupt();
442              assertTrue(sync.isHeldExclusively());              assertTrue(sync.isHeldExclusively());
443              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
444      }      }
445    
446      /**      /**
# Line 509  Line 457 
457      /**      /**
458       * Calling await without holding sync throws IllegalMonitorStateException       * Calling await without holding sync throws IllegalMonitorStateException
459       */       */
460      public void testAwait_IllegalMonitor() {      public void testAwait_IllegalMonitor() throws InterruptedException {
461          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
462          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
463          try {          try {
# Line 518  Line 466 
466          }          }
467          catch (IllegalMonitorStateException success) {          catch (IllegalMonitorStateException success) {
468          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
469      }      }
470    
471      /**      /**
472       * Calling signal without holding sync throws IllegalMonitorStateException       * Calling signal without holding sync throws IllegalMonitorStateException
473       */       */
474      public void testSignal_IllegalMonitor() {      public void testSignal_IllegalMonitor() throws InterruptedException {
475          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
476          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
477          try {          try {
478              c.signal();              c.signal();
479              shouldThrow();              shouldThrow();
480          }          }
481          catch (IllegalMonitorStateException success) {          catch (IllegalMonitorStateException success) {}
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
482      }      }
483    
484      /**      /**
485       * awaitNanos without a signal times out       * awaitNanos without a signal times out
486       */       */
487      public void testAwaitNanos_Timeout() {      public void testAwaitNanos_Timeout() throws InterruptedException {
488          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
489          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
         try {  
490              sync.acquire(1);              sync.acquire(1);
491              long t = c.awaitNanos(100);              long t = c.awaitNanos(100);
492              assertTrue(t <= 0);              assertTrue(t <= 0);
493              sync.release(1);              sync.release(1);
494          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
495    
496      /**      /**
497       *  Timed await without a signal times out       *  Timed await without a signal times out
498       */       */
499      public void testAwait_Timeout() {      public void testAwait_Timeout() throws InterruptedException {
500          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
501          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
         try {  
502              sync.acquire(1);              sync.acquire(1);
503              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
504              sync.release(1);              sync.release(1);
505          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
506    
507      /**      /**
508       * awaitUntil without a signal times out       * awaitUntil without a signal times out
509       */       */
510      public void testAwaitUntil_Timeout() {      public void testAwaitUntil_Timeout() throws InterruptedException {
511          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
512          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
         try {  
513              sync.acquire(1);              sync.acquire(1);
514              java.util.Date d = new java.util.Date();              java.util.Date d = new java.util.Date();
515              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
516              sync.release(1);              sync.release(1);
517          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
518    
519      /**      /**
520       * await returns when signalled       * await returns when signalled
521       */       */
522      public void testAwait() {      public void testAwait() throws InterruptedException {
523          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
524          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
525          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 609  Line 535 
535                  }                  }
536              });              });
537    
         try {  
538              t.start();              t.start();
539              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
540              sync.acquire(1);              sync.acquire(1);
# Line 618  Line 543 
543              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
544              assertFalse(t.isAlive());              assertFalse(t.isAlive());
545          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
546    
547    
548    
# Line 633  Line 554 
554          try {          try {
555              sync.hasWaiters(null);              sync.hasWaiters(null);
556              shouldThrow();              shouldThrow();
557          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
558      }      }
559    
560      /**      /**
# Line 647  Line 565 
565          try {          try {
566              sync.getWaitQueueLength(null);              sync.getWaitQueueLength(null);
567              shouldThrow();              shouldThrow();
568          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
569      }      }
570    
571    
# Line 662  Line 577 
577          try {          try {
578              sync.getWaitingThreads(null);              sync.getWaitingThreads(null);
579              shouldThrow();              shouldThrow();
580          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
581      }      }
582    
583    
# Line 679  Line 591 
591          try {          try {
592              sync2.hasWaiters(c);              sync2.hasWaiters(c);
593              shouldThrow();              shouldThrow();
594          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
595      }      }
596    
597      /**      /**
# Line 694  Line 603 
603          try {          try {
604              sync.hasWaiters(c);              sync.hasWaiters(c);
605              shouldThrow();              shouldThrow();
606          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
607      }      }
608    
609    
# Line 711  Line 617 
617          try {          try {
618              sync2.getWaitQueueLength(c);              sync2.getWaitQueueLength(c);
619              shouldThrow();              shouldThrow();
620          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
621      }      }
622    
623      /**      /**
# Line 726  Line 629 
629          try {          try {
630              sync.getWaitQueueLength(c);              sync.getWaitQueueLength(c);
631              shouldThrow();              shouldThrow();
632          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
633      }      }
634    
635    
# Line 743  Line 643 
643          try {          try {
644              sync2.getWaitingThreads(c);              sync2.getWaitingThreads(c);
645              shouldThrow();              shouldThrow();
646          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
647      }      }
648    
649      /**      /**
# Line 758  Line 655 
655          try {          try {
656              sync.getWaitingThreads(c);              sync.getWaitingThreads(c);
657              shouldThrow();              shouldThrow();
658          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
659      }      }
660    
661    
# Line 769  Line 663 
663      /**      /**
664       * hasWaiters returns true when a thread is waiting, else false       * hasWaiters returns true when a thread is waiting, else false
665       */       */
666      public void testHasWaiters() {      public void testHasWaiters() throws InterruptedException {
667          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
668          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
669          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 787  Line 681 
681                  }                  }
682              });              });
683    
         try {  
684              t.start();              t.start();
685              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
686              sync.acquire(1);              sync.acquire(1);
# Line 803  Line 696 
696              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
697              assertFalse(t.isAlive());              assertFalse(t.isAlive());
698          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
699    
700      /**      /**
701       * getWaitQueueLength returns number of waiting threads       * getWaitQueueLength returns number of waiting threads
702       */       */
703      public void testGetWaitQueueLength() {      public void testGetWaitQueueLength() throws InterruptedException {
704          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
705          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
706          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
# Line 844  Line 733 
733                  }                  }
734              });              });
735    
         try {  
736              t1.start();              t1.start();
737              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
738              t2.start();              t2.start();
# Line 864  Line 752 
752              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
753              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
754          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
755    
756      /**      /**
757       * getWaitingThreads returns only and all waiting threads       * getWaitingThreads returns only and all waiting threads
758       */       */
759      public void testGetWaitingThreads() {      public void testGetWaitingThreads() throws InterruptedException {
760          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
761          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
762          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
# Line 903  Line 787 
787                  }                  }
788              });              });
789    
         try {  
790              sync.acquire(1);              sync.acquire(1);
791              assertTrue(sync.getWaitingThreads(c).isEmpty());              assertTrue(sync.getWaitingThreads(c).isEmpty());
792              sync.release(1);              sync.release(1);
# Line 927  Line 810 
810              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
811              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
812          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
813    
814    
815    
816      /**      /**
817       * awaitUninterruptibly doesn't abort on interrupt       * awaitUninterruptibly doesn't abort on interrupt
818       */       */
819      public void testAwaitUninterruptibly() {      public void testAwaitUninterruptibly() throws InterruptedException {
820          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
821          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
822          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 948  Line 827 
827                  }                  }
828              });              });
829    
         try {  
830              t.start();              t.start();
831              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
832              t.interrupt();              t.interrupt();
# Line 958  Line 836 
836              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
837              assertFalse(t.isAlive());              assertFalse(t.isAlive());
838          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
839    
840      /**      /**
841       * await is interruptible       * await is interruptible
842       */       */
843      public void testAwait_Interrupt() {      public void testAwait_Interrupt() throws InterruptedException {
844          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
845          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
846          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 982  Line 856 
856                  }                  }
857              });              });
858    
         try {  
859              t.start();              t.start();
860              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
861              t.interrupt();              t.interrupt();
862              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
863              assertFalse(t.isAlive());              assertFalse(t.isAlive());
864          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
865    
866      /**      /**
867       * awaitNanos is interruptible       * awaitNanos is interruptible
868       */       */
869      public void testAwaitNanos_Interrupt() {      public void testAwaitNanos_Interrupt() throws InterruptedException {
870          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
871          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
872          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 1013  Line 882 
882                  }                  }
883              });              });
884    
         try {  
885              t.start();              t.start();
886              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
887              t.interrupt();              t.interrupt();
888              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
889              assertFalse(t.isAlive());              assertFalse(t.isAlive());
890          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
891    
892      /**      /**
893       * awaitUntil is interruptible       * awaitUntil is interruptible
894       */       */
895      public void testAwaitUntil_Interrupt() {      public void testAwaitUntil_Interrupt() throws InterruptedException {
896          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
897          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
898          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 1045  Line 909 
909                  }                  }
910              });              });
911    
         try {  
912              t.start();              t.start();
913              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
914              t.interrupt();              t.interrupt();
915              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
916              assertFalse(t.isAlive());              assertFalse(t.isAlive());
917          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
918    
919      /**      /**
920       * signalAll wakes up all threads       * signalAll wakes up all threads
921       */       */
922      public void testSignalAll() {      public void testSignalAll() throws InterruptedException {
923          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
924          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedLongSynchronizer.ConditionObject c = sync.newCondition();
925          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
# Line 1089  Line 948 
948                  }                  }
949              });              });
950    
         try {  
951              t1.start();              t1.start();
952              t2.start();              t2.start();
953              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
# Line 1101  Line 959 
959              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
960              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
961          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
962    
963    
964      /**      /**
# Line 1122  Line 976 
976      /**      /**
977       * A serialized AQS deserializes with current state       * A serialized AQS deserializes with current state
978       */       */
979      public void testSerialization() {      public void testSerialization() throws Exception {
980          Mutex l = new Mutex();          Mutex l = new Mutex();
981          l.acquire(1);          l.acquire(1);
982          assertTrue(l.isHeldExclusively());          assertTrue(l.isHeldExclusively());
983    
         try {  
984              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
985              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
986              out.writeObject(l);              out.writeObject(l);
# Line 1137  Line 990 
990              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
991              Mutex r = (Mutex) in.readObject();              Mutex r = (Mutex) in.readObject();
992              assertTrue(r.isHeldExclusively());              assertTrue(r.isHeldExclusively());
         } catch (Exception e) {  
             e.printStackTrace();  
             unexpectedException();  
         }  
993      }      }
994    
995    
# Line 1169  Line 1018 
1018      /**      /**
1019       * acquireSharedInterruptibly returns after release, but not before       * acquireSharedInterruptibly returns after release, but not before
1020       */       */
1021      public void testAcquireSharedInterruptibly() {      public void testAcquireSharedInterruptibly() throws InterruptedException {
1022          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1023    
1024          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 1183  Line 1032 
1032                      }                      }
1033                  }                  }
1034              });              });
1035          try {  
1036              t.start();              t.start();
1037              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1038              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1039              l.releaseShared(0);              l.releaseShared(0);
1040              assertTrue(l.isSignalled());              assertTrue(l.isSignalled());
1041              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1042      }      }
1043    
1044    
1045      /**      /**
1046       * acquireSharedTimed returns after release       * acquireSharedTimed returns after release
1047       */       */
1048      public void testAsquireSharedTimed() {      public void testAsquireSharedTimed() throws InterruptedException {
1049          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1050    
1051          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 1214  Line 1060 
1060                      }                      }
1061                  }                  }
1062              });              });
1063          try {  
1064              t.start();              t.start();
1065              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1066              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1067              l.releaseShared(0);              l.releaseShared(0);
1068              assertTrue(l.isSignalled());              assertTrue(l.isSignalled());
1069              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1070      }      }
1071    
1072      /**      /**
1073       * acquireSharedInterruptibly throws IE if interrupted before released       * acquireSharedInterruptibly throws IE if interrupted before released
1074       */       */
1075      public void testAcquireSharedInterruptibly_InterruptedException() {      public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {
1076          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1077          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
1078                  public void run() {                  public void run() {
# Line 1240  Line 1083 
1083                      } catch (InterruptedException success) {}                      } catch (InterruptedException success) {}
1084                  }                  }
1085              });              });
1086    
1087          t.start();          t.start();
         try {  
1088              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1089              t.interrupt();              t.interrupt();
1090              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1091      }      }
1092    
1093      /**      /**
1094       * acquireSharedTimed throws IE if interrupted before released       * acquireSharedTimed throws IE if interrupted before released
1095       */       */
1096      public void testAcquireSharedNanos_InterruptedException() {      public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {
1097          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1098          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
1099                  public void run() {                  public void run() {
# Line 1264  Line 1104 
1104                      } catch (InterruptedException success) {}                      } catch (InterruptedException success) {}
1105                  }                  }
1106              });              });
1107    
1108          t.start();          t.start();
         try {  
1109              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1110              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1111              t.interrupt();              t.interrupt();
1112              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1113      }      }
1114    
1115      /**      /**
1116       * acquireSharedTimed times out if not released before timeout       * acquireSharedTimed times out if not released before timeout
1117       */       */
1118      public void testAcquireSharedNanos_Timeout() {      public void testAcquireSharedNanos_Timeout() throws InterruptedException {
1119          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1120          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
1121                  public void run() {                  public void run() {
# Line 1290  Line 1127 
1127                      }                      }
1128                  }                  }
1129              });              });
1130    
1131          t.start();          t.start();
         try {  
1132              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1133              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1134              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1135      }      }
1136    
1137    

Legend:
Removed from v.1.8  
changed lines
  Added in v.1.9

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8