[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.27, Wed Nov 18 08:26:24 2009 UTC revision 1.28, Wed Nov 18 16:04:34 2009 UTC
# Line 65  Line 65 
65      }      }
66    
67      /**      /**
68       * A runnable calling acquireInterruptibly       * A runnable calling acquireInterruptibly that does not expect to
69         * be interrupted.
70       */       */
71      class InterruptibleSyncRunnable implements Runnable {      class InterruptibleSyncRunnable extends CheckedRunnable {
72          final Mutex sync;          final Mutex sync;
73          InterruptibleSyncRunnable(Mutex l) { sync = l; }          InterruptibleSyncRunnable(Mutex l) { sync = l; }
74          public void run() {          public void realRun() throws InterruptedException {
             try {  
75                  sync.acquireInterruptibly(1);                  sync.acquireInterruptibly(1);
             } catch (InterruptedException success) {}  
76          }          }
77      }      }
78    
79    
80      /**      /**
81       * A runnable calling acquireInterruptibly that expects to be       * A runnable calling acquireInterruptibly that expects to be
82       * interrupted       * interrupted.
83       */       */
84      class InterruptedSyncRunnable implements Runnable {      class InterruptedSyncRunnable extends CheckedInterruptedRunnable {
85          final Mutex sync;          final Mutex sync;
86          InterruptedSyncRunnable(Mutex l) { sync = l; }          InterruptedSyncRunnable(Mutex l) { sync = l; }
87          public void run() {          public void realRun() throws InterruptedException {
             try {  
88                  sync.acquireInterruptibly(1);                  sync.acquireInterruptibly(1);
                 threadShouldThrow();  
             } catch (InterruptedException success) {}  
89          }          }
90      }      }
91    
# Line 328  Line 324 
324      public void testInterruptedException2() throws InterruptedException {      public void testInterruptedException2() throws InterruptedException {
325          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
326          sync.acquire(1);          sync.acquire(1);
327          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
328                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
329                          sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);                          sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
330                          threadShouldThrow();              }});
                     } catch (InterruptedException success) {}  
                 }  
             });  
331    
332          t.start();          t.start();
333          t.interrupt();          t.interrupt();
# Line 349  Line 341 
341      public void testTryAcquireWhenSynced() throws InterruptedException {      public void testTryAcquireWhenSynced() throws InterruptedException {
342          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
343          sync.acquire(1);          sync.acquire(1);
344          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
345                  public void run() {              public void realRun() {
346                      threadAssertFalse(sync.tryAcquire(1));                      threadAssertFalse(sync.tryAcquire(1));
347                  }              }});
             });  
348    
349          t.start();          t.start();
350          t.join();          t.join();
# Line 366  Line 357 
357      public void testAcquireNanos_Timeout() throws InterruptedException {      public void testAcquireNanos_Timeout() throws InterruptedException {
358          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
359          sync.acquire(1);          sync.acquire(1);
360          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
361                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
362                          threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000));                          threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000));
363                      } catch (Exception ex) {              }});
                         threadUnexpectedException();  
                     }  
                 }  
             });  
364    
365          t.start();          t.start();
366          t.join();          t.join();
# Line 391  Line 377 
377          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
378          sync.release(1);          sync.release(1);
379          assertFalse(sync.isHeldExclusively());          assertFalse(sync.isHeldExclusively());
380          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
381                  public void run() {              public void realRun() throws InterruptedException {
382                      sync.acquire(1);                      sync.acquire(1);
                     try {  
383                          Thread.sleep(SMALL_DELAY_MS);                          Thread.sleep(SMALL_DELAY_MS);
                     }  
                     catch (Exception e) {  
                         threadUnexpectedException();  
                     }  
384                      sync.release(1);                      sync.release(1);
385                  }              }});
             });  
386    
387          t.start();          t.start();
388          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 461  Line 441 
441          try {          try {
442              c.await();              c.await();
443              shouldThrow();              shouldThrow();
444          }          } catch (IllegalMonitorStateException success) {}
         catch (IllegalMonitorStateException success) {}  
445      }      }
446    
447      /**      /**
# Line 474  Line 453 
453          try {          try {
454              c.signal();              c.signal();
455              shouldThrow();              shouldThrow();
456          }          } catch (IllegalMonitorStateException success) {}
         catch (IllegalMonitorStateException success) {}  
457      }      }
458    
459      /**      /**
# Line 519  Line 497 
497      public void testAwait() throws InterruptedException {      public void testAwait() throws InterruptedException {
498          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
499          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
500          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
501                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
502                          sync.acquire(1);                          sync.acquire(1);
503                          c.await();                          c.await();
504                          sync.release(1);                          sync.release(1);
505                      }              }});
                     catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
506    
507          t.start();          t.start();
508          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 663  Line 635 
635      public void testHasWaiters() throws InterruptedException {      public void testHasWaiters() throws InterruptedException {
636          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
637          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
638          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
639                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
640                          sync.acquire(1);                          sync.acquire(1);
641                          threadAssertFalse(sync.hasWaiters(c));                          threadAssertFalse(sync.hasWaiters(c));
642                          threadAssertEquals(0, sync.getWaitQueueLength(c));                          threadAssertEquals(0, sync.getWaitQueueLength(c));
643                          c.await();                          c.await();
644                          sync.release(1);                          sync.release(1);
645                      }              }});
                     catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
646    
647          t.start();          t.start();
648          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 700  Line 666 
666      public void testGetWaitQueueLength() throws InterruptedException {      public void testGetWaitQueueLength() throws InterruptedException {
667          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
668          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
669          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new CheckedRunnable() {
670                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
671                          sync.acquire(1);                          sync.acquire(1);
672                          threadAssertFalse(sync.hasWaiters(c));                          threadAssertFalse(sync.hasWaiters(c));
673                          threadAssertEquals(0, sync.getWaitQueueLength(c));                          threadAssertEquals(0, sync.getWaitQueueLength(c));
674                          c.await();                          c.await();
675                          sync.release(1);                          sync.release(1);
676                      }              }});
                     catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
677    
678          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new CheckedRunnable() {
679                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
680                          sync.acquire(1);                          sync.acquire(1);
681                          threadAssertTrue(sync.hasWaiters(c));                          threadAssertTrue(sync.hasWaiters(c));
682                          threadAssertEquals(1, sync.getWaitQueueLength(c));                          threadAssertEquals(1, sync.getWaitQueueLength(c));
683                          c.await();                          c.await();
684                          sync.release(1);                          sync.release(1);
685                      }              }});
                     catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
686    
687          t1.start();          t1.start();
688          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 756  Line 710 
710      public void testGetWaitingThreads() throws InterruptedException {      public void testGetWaitingThreads() throws InterruptedException {
711          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
712          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
713          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new CheckedRunnable() {
714                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
715                          sync.acquire(1);                          sync.acquire(1);
716                          threadAssertTrue(sync.getWaitingThreads(c).isEmpty());                          threadAssertTrue(sync.getWaitingThreads(c).isEmpty());
717                          c.await();                          c.await();
718                          sync.release(1);                          sync.release(1);
719                      }              }});
                     catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
720    
721          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new CheckedRunnable() {
722                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
723                          sync.acquire(1);                          sync.acquire(1);
724                          threadAssertFalse(sync.getWaitingThreads(c).isEmpty());                          threadAssertFalse(sync.getWaitingThreads(c).isEmpty());
725                          c.await();                          c.await();
726                          sync.release(1);                          sync.release(1);
727                      }              }});
                     catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
728    
729          sync.acquire(1);          sync.acquire(1);
730          assertTrue(sync.getWaitingThreads(c).isEmpty());          assertTrue(sync.getWaitingThreads(c).isEmpty());
# Line 816  Line 758 
758      public void testAwaitUninterruptibly() throws InterruptedException {      public void testAwaitUninterruptibly() throws InterruptedException {
759          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
760          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
761          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
762                  public void run() {              public void realRun() {
763                      sync.acquire(1);                      sync.acquire(1);
764                      c.awaitUninterruptibly();                      c.awaitUninterruptibly();
765                      sync.release(1);                      sync.release(1);
766                  }              }});
             });  
767    
768          t.start();          t.start();
769          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 840  Line 781 
781      public void testAwait_Interrupt() throws InterruptedException {      public void testAwait_Interrupt() throws InterruptedException {
782          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
783          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
784          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
785                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
786                          sync.acquire(1);                          sync.acquire(1);
787                          c.await();                          c.await();
788                          sync.release(1);                          sync.release(1);
789                          threadShouldThrow();              }});
                     }  
                     catch (InterruptedException success) {  
                     }  
                 }  
             });  
790    
791          t.start();          t.start();
792          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 866  Line 801 
801      public void testAwaitNanos_Interrupt() throws InterruptedException {      public void testAwaitNanos_Interrupt() throws InterruptedException {
802          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
803          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
804          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
805                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
806                          sync.acquire(1);                          sync.acquire(1);
807                          c.awaitNanos(1000 * 1000 * 1000); // 1 sec                          c.awaitNanos(1000 * 1000 * 1000); // 1 sec
808                          sync.release(1);                          sync.release(1);
809                          threadShouldThrow();              }});
                     }  
                     catch (InterruptedException success) {  
                     }  
                 }  
             });  
810    
811          t.start();          t.start();
812          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 892  Line 821 
821      public void testAwaitUntil_Interrupt() throws InterruptedException {      public void testAwaitUntil_Interrupt() throws InterruptedException {
822          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
823          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
824          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
825                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
826                          sync.acquire(1);                          sync.acquire(1);
827                          java.util.Date d = new java.util.Date();                          java.util.Date d = new java.util.Date();
828                          c.awaitUntil(new java.util.Date(d.getTime() + 10000));                          c.awaitUntil(new java.util.Date(d.getTime() + 10000));
829                          sync.release(1);                          sync.release(1);
830                          threadShouldThrow();              }});
                     }  
                     catch (InterruptedException success) {  
                     }  
                 }  
             });  
831    
832          t.start();          t.start();
833          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 919  Line 842 
842      public void testSignalAll() throws InterruptedException {      public void testSignalAll() throws InterruptedException {
843          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
844          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
845          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new CheckedRunnable() {
846                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
847                          sync.acquire(1);                          sync.acquire(1);
848                          c.await();                          c.await();
849                          sync.release(1);                          sync.release(1);
850                      }              }});
                     catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
851    
852          Thread t2 = new Thread(new Runnable() {          Thread t2 = new Thread(new CheckedRunnable() {
853                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
854                          sync.acquire(1);                          sync.acquire(1);
855                          c.await();                          c.await();
856                          sync.release(1);                          sync.release(1);
857                      }              }});
                     catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
858    
859          t1.start();          t1.start();
860          t2.start();          t2.start();
# Line 1018  Line 929 
929      public void testAcquireSharedInterruptibly() throws InterruptedException {      public void testAcquireSharedInterruptibly() throws InterruptedException {
930          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
931    
932          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
933                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
934                          threadAssertFalse(l.isSignalled());                          threadAssertFalse(l.isSignalled());
935                          l.acquireSharedInterruptibly(0);                          l.acquireSharedInterruptibly(0);
936                          threadAssertTrue(l.isSignalled());                          threadAssertTrue(l.isSignalled());
937                      } catch (InterruptedException e) {              }});
                         threadUnexpectedException();  
                     }  
                 }  
             });  
938    
939          t.start();          t.start();
940          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
# Line 1045  Line 951 
951      public void testAsquireSharedTimed() throws InterruptedException {      public void testAsquireSharedTimed() throws InterruptedException {
952          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
953    
954          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
955                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
956                          threadAssertFalse(l.isSignalled());                          threadAssertFalse(l.isSignalled());
957                          threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));                          threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));
958                          threadAssertTrue(l.isSignalled());                          threadAssertTrue(l.isSignalled());
959                }});
                     } catch (InterruptedException e) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
960    
961          t.start();          t.start();
962          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
# Line 1071  Line 971 
971       */       */
972      public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {      public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {
973          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
974          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
975                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
976                          threadAssertFalse(l.isSignalled());                          threadAssertFalse(l.isSignalled());
977                          l.acquireSharedInterruptibly(0);                          l.acquireSharedInterruptibly(0);
978                          threadShouldThrow();              }});
979                      } catch (InterruptedException success) {}  
                 }  
             });  
980          t.start();          t.start();
981          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
982          t.interrupt();          t.interrupt();
# Line 1091  Line 988 
988       */       */
989      public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {      public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {
990          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
991          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
992                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
993                          threadAssertFalse(l.isSignalled());                          threadAssertFalse(l.isSignalled());
994                          l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);                          l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);
995                          threadShouldThrow();              }});
996                      } catch (InterruptedException success) {}  
                 }  
             });  
997          t.start();          t.start();
998          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
999          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
# Line 1112  Line 1006 
1006       */       */
1007      public void testAcquireSharedNanos_Timeout() throws InterruptedException {      public void testAcquireSharedNanos_Timeout() throws InterruptedException {
1008          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1009          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedRunnable() {
1010                  public void run() {              public void realRun() throws InterruptedException {
                     try {  
1011                          threadAssertFalse(l.isSignalled());                          threadAssertFalse(l.isSignalled());
1012                          threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));                          threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));
1013                      } catch (InterruptedException ie) {              }});
1014                          threadUnexpectedException();  
                     }  
                 }  
             });  
1015          t.start();          t.start();
1016          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
1017          assertFalse(l.isSignalled());          assertFalse(l.isSignalled());
1018          t.join();          t.join();
1019      }      }
1020    
   
1021  }  }

Legend:
Removed from v.1.27  
changed lines
  Added in v.1.28

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8