From: erik Date: Mon, 27 Mar 2006 06:47:30 +0000 (+0000) Subject: (no commit message) X-Git-Tag: BEFORE_MAVEN_MIGRATION~138 X-Git-Url: http://wamblee.org/gitweb/?a=commitdiff_plain;h=9fefa51fdacc13d64a526e00043ce9f1f0f86e16;p=utils --- diff --git a/.classpath b/.classpath index 4c7b227e..e8c8128b 100644 --- a/.classpath +++ b/.classpath @@ -35,7 +35,7 @@ - + diff --git a/crawler/basic/src/log4j.properties b/crawler/basic/src/log4j.properties index 65256149..ab710b36 100644 --- a/crawler/basic/src/log4j.properties +++ b/crawler/basic/src/log4j.properties @@ -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 index 00000000..1c1769d3 --- /dev/null +++ b/support/test/org/wamblee/concurrency/AbstractLockTestCase.java @@ -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 _tracker; + + /* + * (non-Javadoc) + * + * @see junit.framework.TestCase#setUp() + */ + @Override + protected void setUp() throws Exception { + _tracker = new EventTracker(); + } + + protected EventTracker 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(); + } +} diff --git a/support/test/org/wamblee/concurrency/JvmLockTest.java b/support/test/org/wamblee/concurrency/JvmLockTest.java index 7d12b381..319c5546 100644 --- a/support/test/org/wamblee/concurrency/JvmLockTest.java +++ b/support/test/org/wamblee/concurrency/JvmLockTest.java @@ -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 _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(); } - 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 index 00000000..f88c4a2f --- /dev/null +++ b/support/test/org/wamblee/concurrency/LockAdviceTest.java @@ -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; + } + +}