commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ozeigerm...@apache.org
Subject cvs commit: jakarta-commons/transaction/src/test/org/apache/commons/transaction/locking GenericLockTest.java
Date Fri, 17 Dec 2004 00:31:22 GMT
ozeigermann    2004/12/16 16:31:22

  Modified:    transaction/src/test/org/apache/commons/transaction/locking
                        GenericLockTest.java
  Log:
  Added test for new read/write/upgrade locks and
  new preference mechanism of GenericLock.
  
  Revision  Changes    Path
  1.4       +148 -6    jakarta-commons/transaction/src/test/org/apache/commons/transaction/locking/GenericLockTest.java
  
  Index: GenericLockTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/transaction/src/test/org/apache/commons/transaction/locking/GenericLockTest.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- GenericLockTest.java	15 Dec 2004 17:36:35 -0000	1.3
  +++ GenericLockTest.java	17 Dec 2004 00:31:22 -0000	1.4
  @@ -29,6 +29,7 @@
   import junit.framework.TestCase;
   import junit.framework.TestSuite;
   
  +import org.apache.commons.transaction.util.CounterBarrier;
   import org.apache.commons.transaction.util.LoggerFacade;
   import org.apache.commons.transaction.util.PrintWriterLogger;
   import org.apache.commons.transaction.util.RendezvousBarrier;
  @@ -46,9 +47,12 @@
       protected static final int READ_LOCK = 1;
       protected static final int WRITE_LOCK = 2;
       
  +    private static final int CONCURRENT_TESTS = 25;
  +    
       protected static final long TIMEOUT = Long.MAX_VALUE;
       
       private static int deadlockCnt = 0;
  +    private static String first = null;
   
       public static Test suite() {
           TestSuite suite = new TestSuite(GenericLockTest.class);
  @@ -73,6 +77,9 @@
       }
       
       public void testBasic() throws Throwable {
  +
  +        sLogger.logInfo("\n\nChecking basic map features\n\n");
  +
           String owner1 = "owner1";
           String owner2 = "owner2";
           String owner3 = "owner3";
  @@ -144,9 +151,11 @@
       }
   
       public void testDeadlock() throws Throwable {
  +
  +        sLogger.logInfo("\n\nChecking deadlock detection\n\n");
  +
           final String owner1 = "owner1";
           final String owner2 = "owner2";
  -        final String owner3 = "owner3";
   
           final String res1 = "res1";
           final String res2 = "res2";
  @@ -157,8 +166,10 @@
           final RendezvousBarrier restart = new RendezvousBarrier("restart",
                   TIMEOUT, sLogger);
   
  -        for (int i = 0; i < 25; i++) {
  +        for (int i = 0; i < CONCURRENT_TESTS; i++) {
   
  +//            System.out.print(".");
  +            
               final RendezvousBarrier deadlockBarrier1 = new RendezvousBarrier("deadlock1"
+ i,
                       TIMEOUT, sLogger);
   
  @@ -218,4 +229,135 @@
           }
       }
   
  +    /*
  +     * 
  +     * Test shows the following
  +     * - upgrade works with read locks no matter if they are acquired before or later (1-4)
  +     * - write is blocked by read (5)
  +     * - read is blocked by intention lock (6)
  +     * - write lock coming from an intention lock always has preference over others (7)
  +     * 
  +     * 
  +     *                  Owner           Owner           Owner
  +     * Step             #1              #2              #3
  +     * 1                read (ok)
  +     * 2                                upgrade (ok)
  +     * 3                release (ok)
  +     * 4                read (ok)
  +     * 5                                write (blocked 
  +     *                                  because of #1)
  +     * 6                                                read (blocked 
  +     *                                                  because intention of #2)      
 
  +     * 7                release         resumed
  +     * 8                                release         resumed
  +     * 9                                                release
  +     */
  +    public void testPreference() throws Throwable {
  +
  +        sLogger.logInfo("\n\nChecking upgrade and preference lock\n\n");
  +        
  +        final String owner1 = "owner1";
  +        final String owner2 = "owner2";
  +        final String owner3 = "owner3";
  +
  +        final String res1 = "res1";
  +
  +        // a read / write lock
  +        final ReadWriteUpgradeLockManager manager = new ReadWriteUpgradeLockManager(sLogger,
  +                TIMEOUT);
  +
  +        final RendezvousBarrier restart = new RendezvousBarrier("restart", 3, TIMEOUT,
sLogger);
  +
  +        final CounterBarrier cb = new CounterBarrier("cb1", TIMEOUT, sLogger);
  +
  +        for (int i = 0; i < CONCURRENT_TESTS; i++) {
  +            
  +//            System.out.print(".");
  +
  +            Thread t1 = new Thread(new Runnable() {
  +                public void run() {
  +                    try {
  +                        cb.count(2);
  +                        manager.upgradeLock(owner2, res1);
  +                        cb.count(3);
  +                        cb.count(6);
  +                        synchronized (manager.getLock(res1)) {
  +                            cb.count(7);
  +                            manager.writeLock(owner2, res1);
  +                        }
  +                        // we must always be first as we will be preferred over
  +                        // as I had the upgrade
  +                        // lock before
  +                        synchronized (this) {
  +                            if (first == null)
  +                                first = owner2;
  +                        }
  +                        cb.count(12);
  +                        manager.releaseAll(owner2);
  +                        cb.count(13);
  +                        synchronized (restart) {
  +                            restart.meet();
  +                            restart.reset();
  +                        }
  +                    } catch (InterruptedException ie) {
  +                    }
  +                }
  +            }, "Thread #1");
  +
  +            t1.start();
  +
  +            Thread t2 = new Thread(new Runnable() {
  +                public void run() {
  +                    try {
  +                        // I wait until the others are blocked
  +                        // when I release my single read lock, thread #1 always
  +                        // should be the
  +                        // next to get the lock as it is preferred over the main
  +                        // thread
  +                        // that only waits for a read lock
  +                        cb.count(8);
  +                        synchronized (manager.getLock(res1)) {
  +                            cb.count(9);
  +                            manager.readLock(owner3, res1);
  +                        }
  +                        synchronized (this) {
  +                            if (first == null)
  +                                first = owner3;
  +                        }
  +                        manager.releaseAll(owner3);
  +                        synchronized (restart) {
  +                            restart.meet();
  +                            restart.reset();
  +                        }
  +                    } catch (InterruptedException ie) {
  +                    }
  +                }
  +            }, "Thread #2");
  +
  +            t2.start();
  +
  +            cb.count(0);
  +            manager.readLock(owner1, res1);
  +            cb.count(1);
  +            cb.count(4);
  +            manager.release(owner1, res1);
  +            manager.readLock(owner1, res1);
  +            cb.count(5);
  +            cb.count(10);
  +            synchronized (manager.getLock(res1)) {
  +                manager.releaseAll(owner1);
  +            }
  +            cb.count(11);
  +            synchronized (restart) {
  +                restart.meet();
  +                restart.reset();
  +            }
  +
  +            assertEquals(first, owner2);
  +            first = null;
  +            cb.reset();
  +        }
  +
  +    }
  +    
   }
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message