ceki        2003/06/02 10:45:06

  Modified:    tests/src/java/org/apache/log4j/helpers VerifierThread.java
                        ReaderWriterLockTestCase.java
               src/java/org/apache/log4j/helpers ReaderWriterLock.java
               tests    build.xml
  Log:
  
  Fixed problems in the TestCase. 
  
  The ReaderWriterLock was modified to cater for the TestCase. Changes will
  be removed after further testing.
  
  Revision  Changes    Path
  1.2       +61 -15    
jakarta-log4j/tests/src/java/org/apache/log4j/helpers/VerifierThread.java
  
  Index: VerifierThread.java
  ===================================================================
  RCS file: 
/home/cvs/jakarta-log4j/tests/src/java/org/apache/log4j/helpers/VerifierThread.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- VerifierThread.java       27 May 2003 20:18:57 -0000      1.1
  +++ VerifierThread.java       2 Jun 2003 17:45:05 -0000       1.2
  @@ -49,6 +49,8 @@
   
   package org.apache.log4j.helpers;
   
  +import junit.framework.TestCase;
  +
   import org.apache.oro.text.perl.Perl5Util;
   
   import java.io.BufferedReader;
  @@ -66,52 +68,72 @@
     boolean[] readLockWaiters;
     boolean[] writerLockWaiters;
     BufferedReader bufferedReader;
  +  double v1 = 0;
  +  double v2 = 0;
  +  Perl5Util regex;
  +  Exception exception;
  +  boolean interrupt;
   
     VerifierThread(BufferedReader br, int numberOfReaders, int numberOfWriters) {
       bufferedReader = br;
       readLockHolders = new boolean[numberOfReaders];
       readLockWaiters = new boolean[numberOfReaders];
       writerLockWaiters = new boolean[numberOfWriters];
  +    regex = new Perl5Util();
  +  }
  +
  +  boolean getInterrupt() {
  +    return interrupt;
     }
   
  - 
     public void run() {
       System.out.println("In run of VerifThread");
  -
  -    Perl5Util regex = new Perl5Util();
  -
  +       String line = null;
  +       
       while (true) {
         try {
  -        String line = bufferedReader.readLine();
  -                 System.out.println(line);               
  -     
  -        if (regex.match("/([RW])-(\\d{1,2}) (.*)/", line)) {
  +        line = bufferedReader.readLine();
  +        if(!interrupt) {
  +          System.out.println(line);
  +        } 
  +        if (regex.match("/([RW])-(\\d{1,3}) (.*)/", line)) {
             String type = regex.group(1);
             int num = Integer.parseInt(regex.group(2));
             String msg = regex.group(3);
   
  +                   //System.out.println(type +"_"+num+ " "+msg);
             if (type.equals("R")) {
               readerMsg(num, msg);
             } else if (type.equals("W")) {
  +            writerMsg(num, msg);
             }
           } else {
             System.out.println(
               "[" + line + "] does not match expected pattern.");
           }
  -
  -        //System.out.println("."+type+"-"+num+" "+msg);                  
  -      } catch (IOException e) {
  +      } catch (Exception e) {
  +             if(exception == null) {
  +          exception = e;
  +             }
  +        interrupt = true;
  +        System.out.println("====Offending line ["+line+"].");
         }
       }
     }
   
  +  public Exception getException() {
  +    return exception;
  +  }
  +
     void readerMsg(int num, String msg) {
       if (msg.equals("Asking for read lock.")) {
         askReadLock(num);
       } else if (msg.equals("Got read lock.")) {
         gotReadLock(num);
  -    } else if (msg.startsWith("Value")) {
  -      //releaseReadLock(num);
  +    } else if (msg.startsWith("Value1")) {
  +      value1Message(num, msg);
  +    } else if (msg.startsWith("Value2")) {
  +      value2Message(num, msg);
       } else if (msg.equals("About to release read lock.")) {
         releaseReadLock(num);
       }
  @@ -122,8 +144,9 @@
         askWriterLock(num);
       } else if (msg.equals("Got write lock.")) {
         gotWriteLock(num);
  -    } else if (msg.startsWith("Value")) {
  -      //releaseReadLock(num);
  +    } else if (msg.equals("About to increment values.")) {
  +      v1 += 1;
  +      v2 += 10.0;
       } else if (msg.equals("About to release write lock.")) {
         releaseWriteLock(num);
       }
  @@ -139,6 +162,7 @@
           return true;
         }
       }
  +
       return false;
     }
   
  @@ -206,5 +230,27 @@
       }
   
       writeLockHolder = -1;
  +  }
  +
  +  void value1Message(int num, String msg) {
  +    if (regex.match("/Value1 is (\\d*)/", msg)) {
  +      double r = Double.parseDouble(regex.group(1));
  +
  +      if (r != v1) {
  +        throw new IllegalStateException(
  +          "Reported value is " + r + " was expecting " + v1);
  +      }
  +    }
  +  }
  +
  +  void value2Message(int num, String msg) {
  +    if (regex.match("/Value1 is (\\d*)/", msg)) {
  +      double r = Double.parseDouble(regex.group(1));
  +
  +      if (r != v2) {
  +        throw new IllegalStateException(
  +          "Reported value is " + r + " was expecting " + v2);
  +      }
  +    }
     }
   }
  
  
  
  1.4       +75 -51    
jakarta-log4j/tests/src/java/org/apache/log4j/helpers/ReaderWriterLockTestCase.java
  
  Index: ReaderWriterLockTestCase.java
  ===================================================================
  RCS file: 
/home/cvs/jakarta-log4j/tests/src/java/org/apache/log4j/helpers/ReaderWriterLockTestCase.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- ReaderWriterLockTestCase.java     27 May 2003 20:30:51 -0000      1.3
  +++ ReaderWriterLockTestCase.java     2 Jun 2003 17:45:05 -0000       1.4
  @@ -53,12 +53,7 @@
   import junit.framework.TestCase;
   import junit.framework.TestSuite;
   
  -import org.apache.log4j.LogManager;
  -
  -import org.apache.oro.text.perl.Perl5Util;
  -
   import java.io.BufferedReader;
  -import java.io.IOException;
   import java.io.PipedReader;
   import java.io.PipedWriter;
   import java.io.PrintWriter;
  @@ -75,17 +70,24 @@
    *
    */
   public class ReaderWriterLockTestCase extends TestCase {
  +  static final int NUM_READERS = 120; //120;
  +  static final int NUM_WRITERS = 4; //4;
  +  static long WLOOP; // number of repetitions for writer threads
  +  static long RLOOP; // number of repetitions for reader threads
     double value1 = 0;
     double value2 = 0;
  -  ReaderWriterLock lock = new ReaderWriterLock();
  +
  +  // this is the object we are testing:
  +  ReaderWriterLock lock;
  +
  +  // The bufferedReader will be passed to the VerifierThread
     BufferedReader bufferedReader;
  +
  +  // This is wehere readers and writers send their output
     PrintWriter printWriter;
  - 
  -  static int WLOOP = 30000;
  -  static int RLOOP = WLOOP*2;
   
     /**
  -   * Constructor for ReaderWriterLockTestCasae.
  +   * Constructor for ReaderWriterLockTestCase.
      * @param arg0
      */
     public ReaderWriterLockTestCase(String arg0) {
  @@ -93,52 +95,59 @@
     }
   
     protected void setUp() throws Exception {
  +    // We write to a piped buffer so that a verifer thread can check the output
       PipedWriter pipedWriter = new PipedWriter();
       PipedReader pipedReader = new PipedReader();
       bufferedReader = new BufferedReader(pipedReader);
       pipedReader.connect(pipedWriter);
   
  -    //pipedWriter.connect(pipedReader);
       printWriter = new PrintWriter(pipedWriter);
  +       lock = new ReaderWriterLock(printWriter);
     }
   
     protected void tearDown() throws Exception {
     }
   
  -  public void test1() {
  -    int maxReaders = 120;
  -    int maxWriters = 4;
  -    Thread[] threads = new Thread[maxReaders + maxWriters];
  +  public void test1() throws Exception {
  +    WLOOP = Long.parseLong(System.getProperty("runLen"));
  +    RLOOP = (long) (WLOOP * (1.0)); // readers loop longer
  +
  +    Thread[] threads = new Thread[NUM_READERS + NUM_WRITERS];
   
  -    VerifierThread vt = new VerifierThread(bufferedReader, maxReaders, maxWriters);
  +    VerifierThread vt =
  +      new VerifierThread(bufferedReader, NUM_READERS, NUM_WRITERS);
       vt.start();
   
  -    for (int i = 0; i < maxReaders; i++) {
  -      threads[i] = new ReaderThread(i);
  +    for (int i = 0; i < NUM_READERS; i++) {
  +      threads[i] = new ReaderThread(i, vt);
       }
   
  -    for (int i = 0; i < maxWriters; i++) {
  -      threads[maxReaders + i] = new WriterThread(i);
  +    for (int i = 0; i < NUM_WRITERS; i++) {
  +      threads[NUM_READERS + i] = new WriterThread(i, vt);
       }
   
  -    for (int i = 0; i < (maxWriters + maxReaders); i++) {
  +    for (int i = 0; i < (NUM_WRITERS + NUM_READERS); i++) {
         threads[i].start();
       }
   
  -    for (int i = 0; i < (maxWriters + maxReaders); i++) {
  +    for (int i = 0; i < (NUM_WRITERS + NUM_READERS); i++) {
         try {
           threads[i].join();
         } catch (InterruptedException e) {
         }
       }
  +
  +    Exception e = vt.getException();
  +
  +    if (e != null) {
  +      throw e;
  +    }
     }
   
  -  void printMessage(String msg) {
  -    synchronized (printWriter) {
  -      //printWriter.print("[");
  -      printWriter.print(Thread.currentThread().getName());
  -      printWriter.print(" ");
  -      printWriter.println(msg);
  +  void delay(long delay) {
  +    try {
  +      Thread.sleep(delay);
  +    } catch (InterruptedException e) {
       }
     }
   
  @@ -149,62 +158,77 @@
       return suite;
     }
   
  +  void printMessage(String msg) {
  +       //printWriter.print("[");      
  +       printWriter.println(Thread.currentThread().getName()+" "+msg);
  +  }
  +
  +
     class ReaderThread extends Thread {
  -    ReaderThread(int i) {
  +    int tNum;
  +    VerifierThread vt;
  +
  +    ReaderThread(int i, VerifierThread vt) {
         super("R-" + i);
  +      tNum = i;
  +      this.vt = vt;
       }
   
       public void run() {
         printMessage("In run()");
   
  -      for (int l = 0; l < RLOOP; l++) {
  -        printMessage("Asking for read lock.");
  +      for (int t = 0; t < RLOOP; t++) {
  +        if (vt.getInterrupt()) {
  +          return;
  +        }
  +
  +        //printMessage("Asking for read lock.");
           lock.getReadLock();
  -        printMessage("Got read lock.");
  +        //printMessage("Got read lock.");
           printMessage("Value1 is " + value1);
           printMessage("Value2 is " + value2);
   
  -        try {
  -          sleep(10);
  -        } catch (InterruptedException e) {
  -        }
  +        delay(10);
   
  -        printMessage("About to release read lock.");
  +        //printMessage("About to release read lock.");
           lock.releaseReadLock();
         }
       }
     }
  -  
  +
     class WriterThread extends Thread {
  -    WriterThread(int i) {
  +    int tNum;
  +    VerifierThread vt;
  +
  +    WriterThread(int i, VerifierThread vt) {
         super("W-" + i);
  +      tNum = i;
  +      this.vt = vt;
       }
   
       public void run() {
         printMessage("In run");
   
  -      for (int i = 0; i < WLOOP; i++) {
  -        try {
  -          sleep(30);
  -        } catch (InterruptedException e) {
  +      for (int t = 0; t < WLOOP; t++) {
  +        if (vt.getInterrupt()) {
  +          return;
           }
   
  -        printMessage("Asking for write lock.");
  +        // on average, the wait is (3.5)*30
  +        delay((((tNum * 13) + t) % 7) * 30);
  +
  +        //printMessage("Asking for write lock.");
           lock.getWriteLock();
  -        printMessage("Got write lock.");
  +        //printMessage("Got write lock.");
           printMessage("About to increment values.");
           value1 += 1;
           value2 += 10;
   
  -        try {
  -          sleep(10);
  -        } catch (InterruptedException e) {
  -        }
  +        delay(10);
   
  -        printMessage("About to release write lock.");
  +        //printMessage("About to release write lock.");
           lock.releaseWriteLock();
         }
       }
     }
  -
   }
  
  
  
  1.2       +86 -35    
jakarta-log4j/src/java/org/apache/log4j/helpers/ReaderWriterLock.java
  
  Index: ReaderWriterLock.java
  ===================================================================
  RCS file: 
/home/cvs/jakarta-log4j/src/java/org/apache/log4j/helpers/ReaderWriterLock.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- ReaderWriterLock.java     24 May 2003 21:04:00 -0000      1.1
  +++ ReaderWriterLock.java     2 Jun 2003 17:45:05 -0000       1.2
  @@ -46,49 +46,100 @@
    * Apache Software Foundation, please see <http://www.apache.org/>.
    *
    */
  +
   package org.apache.log4j.helpers;
   
  +import java.io.PrintWriter;
  +
  +
   /**
  - * 
  + *
    * A RederWriterLock allows multiple readers to obtain the lock at the same time
    * but allows only one writer at a time.
  - * 
  - * Priority is given to waiting writers
  - * 
  + *
  + * When both readers and writers wait to obtain the lock, priority is given to 
  + * waiting writers.
  + *
    * @author Ceki G&uuml;lc&uuml;
    *
    */
   public class ReaderWriterLock {
  +  int readers = 0;
  +  int writers = 0;
  +  int waitingWriters = 0;
  +  PrintWriter printWriter;
  +
  +  public ReaderWriterLock() {
  +  }
  +
  +  public ReaderWriterLock(PrintWriter pw) {
  +    printWriter = pw;
  +  }
  +
  +  public synchronized void getReadLock() {
  +    if (printWriter != null) {
  +      printMessage("Asking for read lock.");
  +    }
  +
  +    while ((writers > 0) || (waitingWriters > 0)) {
  +      try {
  +        wait();
  +      } catch (InterruptedException ie) {
  +      }
  +    }
  +
  +    if (printWriter != null) {
  +      printMessage("Got read lock.");
  +    }
  +
  +    readers++;
  +  }
  +
  +  public synchronized void releaseReadLock() {
  +    if (printWriter != null) {
  +      printMessage("About to release read lock.");
  +    }
  +
  +    readers--;
  +
  +    if (waitingWriters > 0) {
  +      notifyAll();
  +    }
  +  }
  +
  +  public synchronized void getWriteLock() {
  +    if (printWriter != null) {
  +      printMessage("Asking for write lock.");
  +    }
  +
  +    waitingWriters++;
  +
  +    while ((readers > 0) || (writers > 0)) {
  +      try {
  +        wait();
  +      } catch (InterruptedException ie) {
  +      }
  +    }
  +
  +    if (printWriter != null) {
  +      printMessage("Got write lock.");
  +    }
  +
  +    waitingWriters--;
  +    writers++;
  +  }
  +
  +  public synchronized void releaseWriteLock() {
  +    if (printWriter != null) {
  +      printMessage("About to release write lock.");
  +    }
  +
  +    writers--;
  +    notifyAll();
  +  }
   
  -   int readers = 0;
  -   int writers = 0;
  -   int waitingWriters = 0;
  -   
  -   public synchronized void  getReadLock() {     
  -     while(writers > 0 || waitingWriters > 0) {
  -       try {wait();} catch (InterruptedException ie) {} 
  -     }     
  -     readers++;     
  -   }
  -   
  -   public synchronized void releaseReadLock() {
  -     readers --;
  -     if(waitingWriters >0)
  -       notifyAll();
  -   }
  -   
  -   public synchronized void getWriteLock() {
  -     waitingWriters++;
  -     while(readers > 0 || writers > 0) {
  -       try {wait();} catch (InterruptedException ie) {} 
  -     }
  -     waitingWriters--;
  -     writers++;
  -   }
  -   
  -  public synchronized void releaseWriteLock() { 
  -     writers--;
  -     notifyAll();
  -   }
  -   
  +  void printMessage(String msg) {
  +    //printWriter.print("[");      
  +    printWriter.println(Thread.currentThread().getName() + " " + msg);
  +  }
   }
  
  
  
  1.33      +2 -1      jakarta-log4j/tests/build.xml
  
  Index: build.xml
  ===================================================================
  RCS file: /home/cvs/jakarta-log4j/tests/build.xml,v
  retrieving revision 1.32
  retrieving revision 1.33
  diff -u -r1.32 -r1.33
  --- build.xml 24 May 2003 21:04:00 -0000      1.32
  +++ build.xml 2 Jun 2003 17:45:06 -0000       1.33
  @@ -411,7 +411,8 @@
     
    
     <target name="ReaderWriterLock" depends="build, cleanOutputDir">
  -    <junit printsummary="yes" fork="no" haltonfailure="yes">
  +    <junit printsummary="yes" fork="no" haltonfailure="yes"> 
  +      <sysproperty key="runLen" value="10000"/>     
         <classpath refid="tests.classpath"/>
         <formatter type="plain" usefile="false"/>
         <test name="org.apache.log4j.helpers.ReaderWriterLockTestCase" />
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to