(no commit message)
authorerik <erik@77661180-640e-0410-b3a8-9f9b13e6d0e0>
Mon, 27 Mar 2006 06:47:30 +0000 (06:47 +0000)
committererik <erik@77661180-640e-0410-b3a8-9f9b13e6d0e0>
Mon, 27 Mar 2006 06:47:30 +0000 (06:47 +0000)
.classpath
crawler/basic/src/log4j.properties
support/test/org/wamblee/concurrency/AbstractLockTestCase.java [new file with mode: 0644]
support/test/org/wamblee/concurrency/JvmLockTest.java
support/test/org/wamblee/concurrency/LockAdviceTest.java [new file with mode: 0644]

index 4c7b227ec8abe260350a220afc3e63c6152a1a26..e8c8128b7929cf302dc0dfc556862bf381336363 100644 (file)
@@ -35,7 +35,7 @@
        <classpathentry kind="lib" path="support/lib/external/dom4j-1.6.jar"/>
        <classpathentry kind="lib" path="support/lib/external/ehcache-1.1.jar"/>
        <classpathentry kind="lib" path="support/lib/external/log4j-1.2.9.jar"/>
-       <classpathentry kind="lib" path="support/lib/external/spring-1.2.5.jar"/>
+       <classpathentry sourcepath="/usr/java/spring-framework-1.2.5/src" kind="lib" path="support/lib/external/spring-1.2.5.jar"/>
        <classpathentry kind="lib" path="support/lib/test/antlr-2.7.5H3.jar"/>
        <classpathentry kind="lib" path="support/lib/test/asm.jar"/>
        <classpathentry kind="lib" path="support/lib/test/asm-attrs.jar"/>
index 652561490df3476ebabe327405f6966f07fc3d66..ab710b36ed32ca084c93ba8c64e3829a9ba092ac 100644 (file)
@@ -10,7 +10,7 @@
 log4j.rootLogger=ERROR, console
 
 # Log level for wamblee.org
-log4j.logger.org.wamblee=INFO
+log4j.logger.org.wamblee=DEBUG
 log4j.logger.org.wamblee.usermgt.UserAdministrationImplTest=INFO
 log4j.logger.org.wamblee.security.authorization=ERROR
 log4j.logger.org.wamblee.cache=INFO
diff --git a/support/test/org/wamblee/concurrency/AbstractLockTestCase.java b/support/test/org/wamblee/concurrency/AbstractLockTestCase.java
new file mode 100644 (file)
index 0000000..1c1769d
--- /dev/null
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2005 the original author or authors.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.wamblee.concurrency;
+
+import org.wamblee.test.EventTracker;
+import org.wamblee.test.TimingUtils;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests for the JVMLock.
+ */
+public abstract class AbstractLockTestCase extends TestCase {
+
+    protected static final int SLEEP_TIME = 1000;
+
+    protected static final String STARTED = "started";
+
+    protected static final String ACQUIRED = "acquired";
+
+    protected static final String RELEASED = "released";
+
+    private EventTracker<String> _tracker;
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see junit.framework.TestCase#setUp()
+     */
+    @Override
+    protected void setUp() throws Exception {
+        _tracker = new EventTracker<String>();
+    }
+    
+    protected EventTracker<String> getTracker() { 
+        return _tracker;
+    }
+
+    /**
+     * Must be implemented to generate the events 
+     * {@link #STARTED}, {@link #ACQUIRED}, and {@link #RELEASED} in 
+     * that order. The lock should be acquired for
+     * the time specified by {@link #SLEEP_TIME}.
+     * @return Thread which does the work. 
+     */
+    protected abstract Thread runThread();
+
+    /**
+     * Tests the operation of the lock.
+     */
+    public void testLock() throws InterruptedException {
+        Thread t1 = runThread();
+        Thread t2 = runThread();
+        TimingUtils.sleep(SLEEP_TIME / 10); // give threads a chance to start
+        // up.
+        assertEquals(2, _tracker.getEventCount(STARTED)); // both threads
+        // should have
+        // started.
+        assertEquals(1, _tracker.getEventCount(ACQUIRED)); // one thread has
+                                                            // acquired the
+                                                            // lock.
+        TimingUtils.sleep(SLEEP_TIME);
+        assertEquals(2, _tracker.getEventCount(ACQUIRED)); // now the other
+                                                            // thread could also
+                                                            // acquire the lock
+        assertEquals(1, _tracker.getEventCount(RELEASED)); // and the first
+                                                            // thread has
+                                                            // released it.
+        TimingUtils.sleep(SLEEP_TIME);
+        assertEquals(2, _tracker.getEventCount(RELEASED)); // both threads
+                                                            // should be
+                                                            // finished.
+        t1.join();
+        t2.join();
+    }
+}
index 7d12b381483fda61bf48d1cf8b9c633567d02d66..319c5546648c7c1ba34ee222d5ab853c389c14d4 100644 (file)
@@ -24,20 +24,10 @@ import junit.framework.TestCase;
 /**
  * Tests for the JVMLock.
  */
-public class JvmLockTest extends TestCase {
-
-    private static final int SLEEP_TIME = 1000;
-
-    private static final String STARTED = "started";
-
-    private static final String ACQUIRED = "acquired";
-
-    private static final String RELEASED = "released";
+public class JvmLockTest extends AbstractLockTestCase {
 
     private JvmLock _lock;
-
-    private EventTracker<String> _tracker;
-
+    
     /*
      * (non-Javadoc)
      * 
@@ -45,51 +35,22 @@ public class JvmLockTest extends TestCase {
      */
     @Override
     protected void setUp() throws Exception {
+        super.setUp();
         _lock = new JvmLock();
-        _tracker = new EventTracker<String>();
     }
 
-    private Thread runThread() {
+    protected Thread runThread() {
         Thread t = new Thread(new Runnable() {
             public void run() {
-                _tracker.eventOccurred(STARTED);
+                getTracker().eventOccurred(STARTED);
                 _lock.acquire();
-                _tracker.eventOccurred(ACQUIRED);
+                getTracker().eventOccurred(ACQUIRED);
                 TimingUtils.sleep(SLEEP_TIME);
                 _lock.release();
-                _tracker.eventOccurred(RELEASED);
+                getTracker().eventOccurred(RELEASED);
             };
         });
         t.start();
         return t;
     }
-
-    /**
-     * Tests the operation of the lock.
-     */
-    public void testLock() throws InterruptedException {
-        Thread t1 = runThread();
-        Thread t2 = runThread();
-        TimingUtils.sleep(SLEEP_TIME / 10); // give threads a chance to start
-        // up.
-        assertEquals(2, _tracker.getEventCount(STARTED)); // both threads
-        // should have
-        // started.
-        assertEquals(1, _tracker.getEventCount(ACQUIRED)); // one thread has
-                                                            // acquired the
-                                                            // lock.
-        TimingUtils.sleep(SLEEP_TIME);
-        assertEquals(2, _tracker.getEventCount(ACQUIRED)); // now the other
-                                                            // thread could also
-                                                            // acquire the lock
-        assertEquals(1, _tracker.getEventCount(RELEASED)); // and the first
-                                                            // thread has
-                                                            // released it.
-        TimingUtils.sleep(SLEEP_TIME);
-        assertEquals(2, _tracker.getEventCount(RELEASED)); // both threads
-                                                            // should be
-                                                            // finished.
-        t1.join();
-        t2.join();
-    }
 }
diff --git a/support/test/org/wamblee/concurrency/LockAdviceTest.java b/support/test/org/wamblee/concurrency/LockAdviceTest.java
new file mode 100644 (file)
index 0000000..f88c4a2
--- /dev/null
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2005 the original author or authors.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.wamblee.concurrency;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+import org.aopalliance.intercept.MethodInvocation;
+import org.springframework.aop.framework.AdvisedSupport;
+import org.springframework.aop.framework.ProxyFactoryBean;
+import org.springframework.aop.framework.ReflectiveMethodInvocation;
+import org.wamblee.test.TimingUtils;
+
+/**
+ * 
+ */
+public class LockAdviceTest extends AbstractLockTestCase {
+
+    private class Runner implements Runnable {
+        public void run() {
+            LockAdviceTest.this.getTracker().eventOccurred(ACQUIRED);
+            TimingUtils.sleep(SLEEP_TIME);
+        }
+    }
+
+    private Runnable _target;
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see org.wamblee.concurrency.AbstractLockTestCase#setUp()
+     */
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        
+        Runner runner = new Runner();
+        LockAdvice advice = new LockAdvice(new JvmLock());
+        
+        ProxyFactoryBean support = new ProxyFactoryBean();
+        support.setInterfaces(new Class[]{ Runnable.class });
+        support.setTarget(runner);
+        support.addAdvice(advice);
+        _target = (Runnable)support.getObject();
+        
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see org.wamblee.concurrency.AbstractLockTestCase#runThread()
+     */
+    @Override
+    protected Thread runThread() {
+        Thread t = new Thread(new Runnable() {
+            public void run() {
+                try {
+                    getTracker().eventOccurred(STARTED);
+                    _target.run();
+                    getTracker().eventOccurred(RELEASED);
+                } catch (Throwable e) {
+                    throw new RuntimeException(e);
+                }
+            };
+        });
+        t.start();
+        return t;
+    }
+
+}