import java.lang.reflect.Field;
import java.lang.reflect.Method;
-import org.aspectj.util.LangUtil;
-
import junit.framework.TestCase;
+import org.aspectj.util.LangUtil;
+
public class PointcutExpressionTest extends TestCase {
PointcutParser p;
Field n;
Method foo;
Method bar;
-
+
public void testMatchesMethodCall() {
PointcutExpression ex = p.parsePointcutExpression("call(* *..A.a*(..))");
- assertTrue("Should match call to A.a()",ex.matchesMethodCall(a,a).alwaysMatches());
- assertTrue("Should match call to A.aaa()",ex.matchesMethodCall(aaa,a).alwaysMatches());
- assertTrue("Should match call to B.aa()",ex.matchesMethodCall(bsaa,a).alwaysMatches());
- assertTrue("Should not match call to B.b()",ex.matchesMethodCall(b,a).neverMatches());
+ assertTrue("Should match call to A.a()", ex.matchesMethodCall(a, a).alwaysMatches());
+ assertTrue("Should match call to A.aaa()", ex.matchesMethodCall(aaa, a).alwaysMatches());
+ assertTrue("Should match call to B.aa()", ex.matchesMethodCall(bsaa, a).alwaysMatches());
+ assertTrue("Should not match call to B.b()", ex.matchesMethodCall(b, a).neverMatches());
ex = p.parsePointcutExpression("call(* *..A.a*(int))");
- assertTrue("Should match call to A.aa()",ex.matchesMethodCall(aa,a).alwaysMatches());
- assertTrue("Should not match call to A.a()",ex.matchesMethodCall(a,a).neverMatches());
+ assertTrue("Should match call to A.aa()", ex.matchesMethodCall(aa, a).alwaysMatches());
+ assertTrue("Should not match call to A.a()", ex.matchesMethodCall(a, a).neverMatches());
ex = p.parsePointcutExpression("call(void aaa(..)) && this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should match call to A.aaa() from Client",ex.matchesMethodCall(aaa,foo).alwaysMatches());
+ assertTrue("Should match call to A.aaa() from Client", ex.matchesMethodCall(aaa, foo).alwaysMatches());
ex = p.parsePointcutExpression("call(void aaa(..)) && this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Should match call to A.aaa() from B",ex.matchesMethodCall(aaa,b).alwaysMatches());
- assertTrue("May match call to A.aaa() from A",ex.matchesMethodCall(aaa,a).maybeMatches());
- assertFalse("May match call to A.aaa() from A",ex.matchesMethodCall(aaa,a).alwaysMatches());
+ assertTrue("Should match call to A.aaa() from B", ex.matchesMethodCall(aaa, b).alwaysMatches());
+ assertTrue("May match call to A.aaa() from A", ex.matchesMethodCall(aaa, a).maybeMatches());
+ assertFalse("May match call to A.aaa() from A", ex.matchesMethodCall(aaa, a).alwaysMatches());
ex = p.parsePointcutExpression("execution(* *.*(..))");
- assertTrue("Should not match call to A.aa",ex.matchesMethodCall(aa,a).neverMatches());
+ assertTrue("Should not match call to A.aa", ex.matchesMethodCall(aa, a).neverMatches());
// this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should match Client",ex.matchesMethodCall(a,foo).alwaysMatches());
- assertTrue("Should not match A",ex.matchesMethodCall(a,a).neverMatches());
+ assertTrue("Should match Client", ex.matchesMethodCall(a, foo).alwaysMatches());
+ assertTrue("Should not match A", ex.matchesMethodCall(a, a).neverMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Should maybe match B",ex.matchesMethodCall(bsaa,a).maybeMatches());
- assertFalse("Should maybe match B",ex.matchesMethodCall(bsaa,a).alwaysMatches());
+ assertTrue("Should maybe match B", ex.matchesMethodCall(bsaa, a).maybeMatches());
+ assertFalse("Should maybe match B", ex.matchesMethodCall(bsaa, a).alwaysMatches());
// target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should not match Client",ex.matchesMethodCall(a,a).neverMatches());
+ assertTrue("Should not match Client", ex.matchesMethodCall(a, a).neverMatches());
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("Should match A",ex.matchesMethodCall(a,a).alwaysMatches());
+ assertTrue("Should match A", ex.matchesMethodCall(a, a).alwaysMatches());
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Should maybe match A",ex.matchesMethodCall(aa,a).maybeMatches());
- assertFalse("Should maybe match A",ex.matchesMethodCall(aa,a).alwaysMatches());
+ assertTrue("Should maybe match A", ex.matchesMethodCall(aa, a).maybeMatches());
+ assertFalse("Should maybe match A", ex.matchesMethodCall(aa, a).alwaysMatches());
// test args
ex = p.parsePointcutExpression("args(..,int)");
- assertTrue("Should match A.aa",ex.matchesMethodCall(aa,a).alwaysMatches());
- assertTrue("Should match A.aaa",ex.matchesMethodCall(aaa,a).alwaysMatches());
- assertTrue("Should not match A.a",ex.matchesMethodCall(a,a).neverMatches());
+ assertTrue("Should match A.aa", ex.matchesMethodCall(aa, a).alwaysMatches());
+ assertTrue("Should match A.aaa", ex.matchesMethodCall(aaa, a).alwaysMatches());
+ assertTrue("Should not match A.a", ex.matchesMethodCall(a, a).neverMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesMethodCall(a,a).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesMethodCall(a,b).neverMatches());
- assertTrue("Matches in class A",ex.matchesMethodCall(a,A.class).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesMethodCall(a,B.class).neverMatches());
+ assertTrue("Matches in class A", ex.matchesMethodCall(a, a).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesMethodCall(a, b).neverMatches());
+ assertTrue("Matches in class A", ex.matchesMethodCall(a, A.class).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesMethodCall(a, B.class).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Should match",ex.matchesMethodCall(b,bsaa).alwaysMatches());
- assertTrue("Should not match",ex.matchesMethodCall(b,b).neverMatches());
+ assertTrue("Should match", ex.matchesMethodCall(b, bsaa).alwaysMatches());
+ assertTrue("Should not match", ex.matchesMethodCall(b, b).neverMatches());
}
public void testMatchesMethodExecution() {
PointcutExpression ex = p.parsePointcutExpression("execution(* *..A.aa(..))");
- assertTrue("Should match execution of A.aa",ex.matchesMethodExecution(aa).alwaysMatches());
- assertTrue("Should match execution of B.aa",ex.matchesMethodExecution(bsaa).alwaysMatches());
- assertTrue("Should not match execution of A.a",ex.matchesMethodExecution(a).neverMatches());
+ assertTrue("Should match execution of A.aa", ex.matchesMethodExecution(aa).alwaysMatches());
+ assertTrue("Should match execution of B.aa", ex.matchesMethodExecution(bsaa).alwaysMatches());
+ assertTrue("Should not match execution of A.a", ex.matchesMethodExecution(a).neverMatches());
ex = p.parsePointcutExpression("call(* *..A.a*(int))");
- assertTrue("Should not match execution of A.a",ex.matchesMethodExecution(a).neverMatches());
+ assertTrue("Should not match execution of A.a", ex.matchesMethodExecution(a).neverMatches());
// test this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("Should match A",ex.matchesMethodExecution(a).alwaysMatches());
+ assertTrue("Should match A", ex.matchesMethodExecution(a).alwaysMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesMethodExecution(a).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesMethodExecution(a).alwaysMatches());
+ assertTrue("Maybe matches B", ex.matchesMethodExecution(a).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesMethodExecution(a).alwaysMatches());
// test target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("Should match A",ex.matchesMethodExecution(a).alwaysMatches());
+ assertTrue("Should match A", ex.matchesMethodExecution(a).alwaysMatches());
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesMethodExecution(a).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesMethodExecution(a).alwaysMatches());
-
+ assertTrue("Maybe matches B", ex.matchesMethodExecution(a).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesMethodExecution(a).alwaysMatches());
+
// test args
ex = p.parsePointcutExpression("args(..,int)");
- assertTrue("Should match A.aa",ex.matchesMethodExecution(aa).alwaysMatches());
- assertTrue("Should match A.aaa",ex.matchesMethodExecution(aaa).alwaysMatches());
- assertTrue("Should not match A.a",ex.matchesMethodExecution(a).neverMatches());
+ assertTrue("Should match A.aa", ex.matchesMethodExecution(aa).alwaysMatches());
+ assertTrue("Should match A.aaa", ex.matchesMethodExecution(aaa).alwaysMatches());
+ assertTrue("Should not match A.a", ex.matchesMethodExecution(a).neverMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesMethodExecution(a).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesMethodExecution(bsaa).neverMatches());
+ assertTrue("Matches in class A", ex.matchesMethodExecution(a).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesMethodExecution(bsaa).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Should not match",ex.matchesMethodExecution(a).neverMatches());
+ assertTrue("Should not match", ex.matchesMethodExecution(a).neverMatches());
}
public void testMatchesConstructorCall() {
PointcutExpression ex = p.parsePointcutExpression("call(new(String))");
- assertTrue("Should match A(String)", ex.matchesConstructorCall(asCons,b).alwaysMatches());
- assertTrue("Should match B(String)", ex.matchesConstructorCall(bsStringCons,b).alwaysMatches());
- assertTrue("Should not match B()",ex.matchesConstructorCall(bsCons,foo).neverMatches());
+ assertTrue("Should match A(String)", ex.matchesConstructorCall(asCons, b).alwaysMatches());
+ assertTrue("Should match B(String)", ex.matchesConstructorCall(bsStringCons, b).alwaysMatches());
+ assertTrue("Should not match B()", ex.matchesConstructorCall(bsCons, foo).neverMatches());
ex = p.parsePointcutExpression("call(*..A.new(String))");
- assertTrue("Should match A(String)", ex.matchesConstructorCall(asCons,b).alwaysMatches());
- assertTrue("Should not match B(String)",ex.matchesConstructorCall(bsStringCons,foo).neverMatches());
+ assertTrue("Should match A(String)", ex.matchesConstructorCall(asCons, b).alwaysMatches());
+ assertTrue("Should not match B(String)", ex.matchesConstructorCall(bsStringCons, foo).neverMatches());
// this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should match Client",ex.matchesConstructorCall(asCons,foo).alwaysMatches());
- assertTrue("Should not match A",ex.matchesConstructorCall(asCons,a).neverMatches());
+ assertTrue("Should match Client", ex.matchesConstructorCall(asCons, foo).alwaysMatches());
+ assertTrue("Should not match A", ex.matchesConstructorCall(asCons, a).neverMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Should maybe match B",ex.matchesConstructorCall(asCons,a).maybeMatches());
- assertFalse("Should maybe match B",ex.matchesConstructorCall(asCons,a).alwaysMatches());
+ assertTrue("Should maybe match B", ex.matchesConstructorCall(asCons, a).maybeMatches());
+ assertFalse("Should maybe match B", ex.matchesConstructorCall(asCons, a).alwaysMatches());
// target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should not match Client",ex.matchesConstructorCall(asCons,foo).neverMatches());
+ assertTrue("Should not match Client", ex.matchesConstructorCall(asCons, foo).neverMatches());
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("Should not match A (no target)",ex.matchesConstructorCall(asCons,a).neverMatches());
+ assertTrue("Should not match A (no target)", ex.matchesConstructorCall(asCons, a).neverMatches());
// args
ex = p.parsePointcutExpression("args(String)");
- assertTrue("Should match A(String)", ex.matchesConstructorCall(asCons,b).alwaysMatches());
- assertTrue("Should match B(String)", ex.matchesConstructorCall(bsStringCons,foo).alwaysMatches());
- assertTrue("Should not match B()", ex.matchesConstructorCall(bsCons,foo).neverMatches());
+ assertTrue("Should match A(String)", ex.matchesConstructorCall(asCons, b).alwaysMatches());
+ assertTrue("Should match B(String)", ex.matchesConstructorCall(bsStringCons, foo).alwaysMatches());
+ assertTrue("Should not match B()", ex.matchesConstructorCall(bsCons, foo).neverMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesConstructorCall(asCons,a).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesConstructorCall(asCons,b).neverMatches());
+ assertTrue("Matches in class A", ex.matchesConstructorCall(asCons, a).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesConstructorCall(asCons, b).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Should match",ex.matchesConstructorCall(bsCons,aa).alwaysMatches());
- assertTrue("Should not match",ex.matchesConstructorCall(bsCons,b).neverMatches());
+ assertTrue("Should match", ex.matchesConstructorCall(bsCons, aa).alwaysMatches());
+ assertTrue("Should not match", ex.matchesConstructorCall(bsCons, b).neverMatches());
}
public void testMatchesConstructorExecution() {
assertTrue("Should match B(String)", ex.matchesConstructorExecution(bsStringCons).alwaysMatches());
assertTrue("Should not match B()", ex.matchesConstructorExecution(bsCons).neverMatches());
ex = p.parsePointcutExpression("execution(*..A.new(String))");
- assertTrue("Should match A(String)",ex.matchesConstructorExecution(asCons).alwaysMatches());
- assertTrue("Should not match B(String)",ex.matchesConstructorExecution(bsStringCons).neverMatches());
+ assertTrue("Should match A(String)", ex.matchesConstructorExecution(asCons).alwaysMatches());
+ assertTrue("Should not match B(String)", ex.matchesConstructorExecution(bsStringCons).neverMatches());
// test this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("Should match A",ex.matchesConstructorExecution(asCons).alwaysMatches());
+ assertTrue("Should match A", ex.matchesConstructorExecution(asCons).alwaysMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesConstructorExecution(asCons).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesConstructorExecution(asCons).alwaysMatches());
- assertTrue("Should match B",ex.matchesConstructorExecution(bsCons).alwaysMatches());
- assertTrue("Does not match client",ex.matchesConstructorExecution(clientCons).neverMatches());
+ assertTrue("Maybe matches B", ex.matchesConstructorExecution(asCons).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesConstructorExecution(asCons).alwaysMatches());
+ assertTrue("Should match B", ex.matchesConstructorExecution(bsCons).alwaysMatches());
+ assertTrue("Does not match client", ex.matchesConstructorExecution(clientCons).neverMatches());
// test target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("Should match A",ex.matchesConstructorExecution(asCons).alwaysMatches());
+ assertTrue("Should match A", ex.matchesConstructorExecution(asCons).alwaysMatches());
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesConstructorExecution(asCons).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesConstructorExecution(asCons).alwaysMatches());
- assertTrue("Should match B",ex.matchesConstructorExecution(bsCons).alwaysMatches());
- assertTrue("Does not match client",ex.matchesConstructorExecution(clientCons).neverMatches());
+ assertTrue("Maybe matches B", ex.matchesConstructorExecution(asCons).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesConstructorExecution(asCons).alwaysMatches());
+ assertTrue("Should match B", ex.matchesConstructorExecution(bsCons).alwaysMatches());
+ assertTrue("Does not match client", ex.matchesConstructorExecution(clientCons).neverMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesConstructorExecution(asCons).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesConstructorExecution(bsCons).neverMatches());
+ assertTrue("Matches in class A", ex.matchesConstructorExecution(asCons).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesConstructorExecution(bsCons).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Does not match",ex.matchesConstructorExecution(bsCons).neverMatches());
+ assertTrue("Does not match", ex.matchesConstructorExecution(bsCons).neverMatches());
// args
ex = p.parsePointcutExpression("args(String)");
- assertTrue("Should match A(String)",ex.matchesConstructorExecution(asCons).alwaysMatches());
+ assertTrue("Should match A(String)", ex.matchesConstructorExecution(asCons).alwaysMatches());
assertTrue("Should match B(String)", ex.matchesConstructorExecution(bsStringCons).alwaysMatches());
assertTrue("Should not match B()", ex.matchesConstructorExecution(bsCons).neverMatches());
}
public void testMatchesAdviceExecution() {
PointcutExpression ex = p.parsePointcutExpression("adviceexecution()");
- assertTrue("Should match (advice) A.a",ex.matchesAdviceExecution(a).alwaysMatches());
+ assertTrue("Should match (advice) A.a", ex.matchesAdviceExecution(a).alwaysMatches());
// test this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should match Client",ex.matchesAdviceExecution(foo).alwaysMatches());
+ assertTrue("Should match Client", ex.matchesAdviceExecution(foo).alwaysMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesAdviceExecution(a).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesAdviceExecution(a).alwaysMatches());
- assertTrue("Does not match client",ex.matchesAdviceExecution(foo).neverMatches());
+ assertTrue("Maybe matches B", ex.matchesAdviceExecution(a).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesAdviceExecution(a).alwaysMatches());
+ assertTrue("Does not match client", ex.matchesAdviceExecution(foo).neverMatches());
// test target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should match Client",ex.matchesAdviceExecution(foo).alwaysMatches());
+ assertTrue("Should match Client", ex.matchesAdviceExecution(foo).alwaysMatches());
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesAdviceExecution(a).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesAdviceExecution(a).alwaysMatches());
- assertTrue("Does not match client",ex.matchesAdviceExecution(foo).neverMatches());
+ assertTrue("Maybe matches B", ex.matchesAdviceExecution(a).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesAdviceExecution(a).alwaysMatches());
+ assertTrue("Does not match client", ex.matchesAdviceExecution(foo).neverMatches());
// test within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesAdviceExecution(a).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesAdviceExecution(b).neverMatches());
+ assertTrue("Matches in class A", ex.matchesAdviceExecution(a).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesAdviceExecution(b).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Does not match",ex.matchesAdviceExecution(a).neverMatches());
+ assertTrue("Does not match", ex.matchesAdviceExecution(a).neverMatches());
// test args
ex = p.parsePointcutExpression("args(..,int)");
- assertTrue("Should match A.aa",ex.matchesAdviceExecution(aa).alwaysMatches());
- assertTrue("Should match A.aaa",ex.matchesAdviceExecution(aaa).alwaysMatches());
- assertTrue("Should not match A.a",ex.matchesAdviceExecution(a).neverMatches());
+ assertTrue("Should match A.aa", ex.matchesAdviceExecution(aa).alwaysMatches());
+ assertTrue("Should match A.aaa", ex.matchesAdviceExecution(aaa).alwaysMatches());
+ assertTrue("Should not match A.a", ex.matchesAdviceExecution(a).neverMatches());
}
public void testMatchesHandler() {
PointcutExpression ex = p.parsePointcutExpression("handler(Exception)");
- assertTrue("Should match catch(Exception)",ex.matchesHandler(Exception.class,Client.class).alwaysMatches());
- assertTrue("Should not match catch(Throwable)",ex.matchesHandler(Throwable.class,Client.class).neverMatches());
+ assertTrue("Should match catch(Exception)", ex.matchesHandler(Exception.class, Client.class).alwaysMatches());
+ assertTrue("Should not match catch(Throwable)", ex.matchesHandler(Throwable.class, Client.class).neverMatches());
// test this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should match Client",ex.matchesHandler(Exception.class,foo).alwaysMatches());
+ assertTrue("Should match Client", ex.matchesHandler(Exception.class, foo).alwaysMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesHandler(Exception.class,a).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesHandler(Exception.class,a).alwaysMatches());
- assertTrue("Does not match client",ex.matchesHandler(Exception.class,foo).neverMatches());
+ assertTrue("Maybe matches B", ex.matchesHandler(Exception.class, a).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesHandler(Exception.class, a).alwaysMatches());
+ assertTrue("Does not match client", ex.matchesHandler(Exception.class, foo).neverMatches());
// target - no target for exception handlers
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("Should match Client",ex.matchesHandler(Exception.class,foo).neverMatches());
+ assertTrue("Should match Client", ex.matchesHandler(Exception.class, foo).neverMatches());
// args
ex = p.parsePointcutExpression("args(Exception)");
- assertTrue("Should match Exception",ex.matchesHandler(Exception.class,foo).alwaysMatches());
- assertTrue("Should match RuntimeException",ex.matchesHandler(RuntimeException.class,foo).alwaysMatches());
- assertTrue("Should not match String",ex.matchesHandler(String.class,foo).neverMatches());
- assertTrue("Maybe matches Throwable",ex.matchesHandler(Throwable.class,foo).maybeMatches());
- assertFalse("Maybe matches Throwable",ex.matchesHandler(Throwable.class,foo).alwaysMatches());
+ assertTrue("Should match Exception", ex.matchesHandler(Exception.class, foo).alwaysMatches());
+ assertTrue("Should match RuntimeException", ex.matchesHandler(RuntimeException.class, foo).alwaysMatches());
+ assertTrue("Should not match String", ex.matchesHandler(String.class, foo).neverMatches());
+ assertTrue("Maybe matches Throwable", ex.matchesHandler(Throwable.class, foo).maybeMatches());
+ assertFalse("Maybe matches Throwable", ex.matchesHandler(Throwable.class, foo).alwaysMatches());
// within
ex = p.parsePointcutExpression("within(*..Client)");
- assertTrue("Matches in class Client",ex.matchesHandler(Exception.class,foo).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesHandler(Exception.class,b).neverMatches());
+ assertTrue("Matches in class Client", ex.matchesHandler(Exception.class, foo).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesHandler(Exception.class, b).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Matches within aa",ex.matchesHandler(Exception.class,aa).alwaysMatches());
- assertTrue("Does not match within b",ex.matchesHandler(Exception.class,b).neverMatches());
+ assertTrue("Matches within aa", ex.matchesHandler(Exception.class, aa).alwaysMatches());
+ assertTrue("Does not match within b", ex.matchesHandler(Exception.class, b).neverMatches());
}
public void testMatchesInitialization() {
PointcutExpression ex = p.parsePointcutExpression("initialization(new(String))");
- assertTrue("Should match A(String)",ex.matchesInitialization(asCons).alwaysMatches());
+ assertTrue("Should match A(String)", ex.matchesInitialization(asCons).alwaysMatches());
assertTrue("Should match B(String)", ex.matchesInitialization(bsStringCons).alwaysMatches());
- assertTrue("Should not match B()",ex.matchesInitialization(bsCons).neverMatches());
+ assertTrue("Should not match B()", ex.matchesInitialization(bsCons).neverMatches());
ex = p.parsePointcutExpression("initialization(*..A.new(String))");
assertTrue("Should match A(String)", ex.matchesInitialization(asCons).alwaysMatches());
assertTrue("Should not match B(String)", ex.matchesInitialization(bsStringCons).neverMatches());
// test this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("Should match A",ex.matchesInitialization(asCons).alwaysMatches());
+ assertTrue("Should match A", ex.matchesInitialization(asCons).alwaysMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesInitialization(asCons).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesInitialization(asCons).alwaysMatches());
-
+ assertTrue("Maybe matches B", ex.matchesInitialization(asCons).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesInitialization(asCons).alwaysMatches());
+
// test target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("Should match A",ex.matchesInitialization(asCons).alwaysMatches());
+ assertTrue("Should match A", ex.matchesInitialization(asCons).alwaysMatches());
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("Maybe matches B",ex.matchesInitialization(asCons).maybeMatches());
- assertFalse("Maybe matches B",ex.matchesInitialization(asCons).alwaysMatches());
+ assertTrue("Maybe matches B", ex.matchesInitialization(asCons).maybeMatches());
+ assertFalse("Maybe matches B", ex.matchesInitialization(asCons).alwaysMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesInitialization(asCons).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesInitialization(bsCons).neverMatches());
+ assertTrue("Matches in class A", ex.matchesInitialization(asCons).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesInitialization(bsCons).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Does not match",ex.matchesInitialization(bsCons).neverMatches());
+ assertTrue("Does not match", ex.matchesInitialization(bsCons).neverMatches());
// args
ex = p.parsePointcutExpression("args(String)");
assertTrue("Should match A(String)", ex.matchesInitialization(asCons).alwaysMatches());
assertTrue("Should match B(String)", ex.matchesInitialization(bsStringCons).alwaysMatches());
- assertTrue("Should not match B()",ex.matchesInitialization(bsCons).neverMatches());
+ assertTrue("Should not match B()", ex.matchesInitialization(bsCons).neverMatches());
}
public void testMatchesPreInitialization() {
PointcutExpression ex = p.parsePointcutExpression("preinitialization(new(String))");
- assertTrue("Should match A(String)",ex.matchesPreInitialization(asCons).alwaysMatches());
+ assertTrue("Should match A(String)", ex.matchesPreInitialization(asCons).alwaysMatches());
assertTrue("Should match B(String)", ex.matchesPreInitialization(bsStringCons).alwaysMatches());
- assertTrue("Should not match B()",ex.matchesPreInitialization(bsCons).neverMatches());
+ assertTrue("Should not match B()", ex.matchesPreInitialization(bsCons).neverMatches());
ex = p.parsePointcutExpression("preinitialization(*..A.new(String))");
assertTrue("Should match A(String)", ex.matchesPreInitialization(asCons).alwaysMatches());
assertTrue("Should not match B(String)", ex.matchesPreInitialization(bsStringCons).neverMatches());
// test this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("No match, no this at preinit",ex.matchesPreInitialization(asCons).neverMatches());
-
+ assertTrue("No match, no this at preinit", ex.matchesPreInitialization(asCons).neverMatches());
+
// test target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("No match, no target at preinit",ex.matchesPreInitialization(asCons).neverMatches());
+ assertTrue("No match, no target at preinit", ex.matchesPreInitialization(asCons).neverMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesPreInitialization(asCons).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesPreInitialization(bsCons).neverMatches());
+ assertTrue("Matches in class A", ex.matchesPreInitialization(asCons).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesPreInitialization(bsCons).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Does not match",ex.matchesPreInitialization(bsCons).neverMatches());
+ assertTrue("Does not match", ex.matchesPreInitialization(bsCons).neverMatches());
// args
ex = p.parsePointcutExpression("args(String)");
assertTrue("Should match A(String)", ex.matchesPreInitialization(asCons).alwaysMatches());
assertTrue("Should match B(String)", ex.matchesPreInitialization(bsStringCons).alwaysMatches());
- assertTrue("Should not match B()",ex.matchesPreInitialization(bsCons).neverMatches());
+ assertTrue("Should not match B()", ex.matchesPreInitialization(bsCons).neverMatches());
}
public void testMatchesStaticInitialization() {
// staticinit
PointcutExpression ex = p.parsePointcutExpression("staticinitialization(*..A+)");
- assertTrue("Matches A",ex.matchesStaticInitialization(A.class).alwaysMatches());
- assertTrue("Matches B",ex.matchesStaticInitialization(B.class).alwaysMatches());
- assertTrue("Doesn't match Client",ex.matchesStaticInitialization(Client.class).neverMatches());
+ assertTrue("Matches A", ex.matchesStaticInitialization(A.class).alwaysMatches());
+ assertTrue("Matches B", ex.matchesStaticInitialization(B.class).alwaysMatches());
+ assertTrue("Doesn't match Client", ex.matchesStaticInitialization(Client.class).neverMatches());
// this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("No this",ex.matchesStaticInitialization(A.class).neverMatches());
+ assertTrue("No this", ex.matchesStaticInitialization(A.class).neverMatches());
// target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
- assertTrue("No target",ex.matchesStaticInitialization(A.class).neverMatches());
+ assertTrue("No target", ex.matchesStaticInitialization(A.class).neverMatches());
// args
ex = p.parsePointcutExpression("args()");
- assertTrue("No args",ex.matchesStaticInitialization(A.class).alwaysMatches());
+ assertTrue("No args", ex.matchesStaticInitialization(A.class).alwaysMatches());
ex = p.parsePointcutExpression("args(String)");
- assertTrue("No args",ex.matchesStaticInitialization(A.class).neverMatches());
+ assertTrue("No args", ex.matchesStaticInitialization(A.class).neverMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesStaticInitialization(A.class).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesStaticInitialization(B.class).neverMatches());
+ assertTrue("Matches in class A", ex.matchesStaticInitialization(A.class).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesStaticInitialization(B.class).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Does not match",ex.matchesStaticInitialization(A.class).neverMatches());
+ assertTrue("Does not match", ex.matchesStaticInitialization(A.class).neverMatches());
}
public void testMatchesFieldSet() {
PointcutExpression ex = p.parsePointcutExpression("set(* *..A+.*)");
- assertTrue("matches x",ex.matchesFieldSet(x,a).alwaysMatches());
- assertTrue("matches y",ex.matchesFieldSet(y,foo).alwaysMatches());
- assertTrue("does not match n",ex.matchesFieldSet(n,foo).neverMatches());
+ assertTrue("matches x", ex.matchesFieldSet(x, a).alwaysMatches());
+ assertTrue("matches y", ex.matchesFieldSet(y, foo).alwaysMatches());
+ assertTrue("does not match n", ex.matchesFieldSet(n, foo).neverMatches());
// this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("matches Client",ex.matchesFieldSet(x,foo).alwaysMatches());
- assertTrue("does not match A",ex.matchesFieldSet(n,a).neverMatches());
+ assertTrue("matches Client", ex.matchesFieldSet(x, foo).alwaysMatches());
+ assertTrue("does not match A", ex.matchesFieldSet(n, a).neverMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("maybe matches A",ex.matchesFieldSet(x,a).maybeMatches());
- assertFalse("maybe matches A",ex.matchesFieldSet(x,a).alwaysMatches());
+ assertTrue("maybe matches A", ex.matchesFieldSet(x, a).maybeMatches());
+ assertFalse("maybe matches A", ex.matchesFieldSet(x, a).alwaysMatches());
// target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("matches B",ex.matchesFieldSet(y,foo).alwaysMatches());
- assertTrue("maybe matches A",ex.matchesFieldSet(x,foo).maybeMatches());
- assertFalse("maybe matches A",ex.matchesFieldSet(x,foo).alwaysMatches());
+ assertTrue("matches B", ex.matchesFieldSet(y, foo).alwaysMatches());
+ assertTrue("maybe matches A", ex.matchesFieldSet(x, foo).maybeMatches());
+ assertFalse("maybe matches A", ex.matchesFieldSet(x, foo).alwaysMatches());
// args
ex = p.parsePointcutExpression("args(int)");
- assertTrue("matches x",ex.matchesFieldSet(x,a).alwaysMatches());
- assertTrue("matches y",ex.matchesFieldSet(y,a).alwaysMatches());
- assertTrue("does not match n",ex.matchesFieldSet(n,a).neverMatches());
+ assertTrue("matches x", ex.matchesFieldSet(x, a).alwaysMatches());
+ assertTrue("matches y", ex.matchesFieldSet(y, a).alwaysMatches());
+ assertTrue("does not match n", ex.matchesFieldSet(n, a).neverMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesFieldSet(x,a).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesFieldSet(x,b).neverMatches());
+ assertTrue("Matches in class A", ex.matchesFieldSet(x, a).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesFieldSet(x, b).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Should match",ex.matchesFieldSet(x,aa).alwaysMatches());
- assertTrue("Should not match",ex.matchesFieldSet(x,b).neverMatches());
+ assertTrue("Should match", ex.matchesFieldSet(x, aa).alwaysMatches());
+ assertTrue("Should not match", ex.matchesFieldSet(x, b).neverMatches());
}
public void testMatchesFieldGet() {
PointcutExpression ex = p.parsePointcutExpression("get(* *..A+.*)");
- assertTrue("matches x",ex.matchesFieldGet(x,a).alwaysMatches());
- assertTrue("matches y",ex.matchesFieldGet(y,foo).alwaysMatches());
- assertTrue("does not match n",ex.matchesFieldGet(n,foo).neverMatches());
+ assertTrue("matches x", ex.matchesFieldGet(x, a).alwaysMatches());
+ assertTrue("matches y", ex.matchesFieldGet(y, foo).alwaysMatches());
+ assertTrue("does not match n", ex.matchesFieldGet(n, foo).neverMatches());
// this
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
- assertTrue("matches Client",ex.matchesFieldGet(x,foo).alwaysMatches());
- assertTrue("does not match A",ex.matchesFieldGet(n,a).neverMatches());
+ assertTrue("matches Client", ex.matchesFieldGet(x, foo).alwaysMatches());
+ assertTrue("does not match A", ex.matchesFieldGet(n, a).neverMatches());
ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("maybe matches A",ex.matchesFieldGet(x,a).maybeMatches());
- assertFalse("maybe matches A",ex.matchesFieldGet(x,a).alwaysMatches());
+ assertTrue("maybe matches A", ex.matchesFieldGet(x, a).maybeMatches());
+ assertFalse("maybe matches A", ex.matchesFieldGet(x, a).alwaysMatches());
// target
ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertTrue("matches B",ex.matchesFieldGet(y,foo).alwaysMatches());
- assertTrue("maybe matches A",ex.matchesFieldGet(x,foo).maybeMatches());
- assertFalse("maybe matches A",ex.matchesFieldGet(x,foo).alwaysMatches());
+ assertTrue("matches B", ex.matchesFieldGet(y, foo).alwaysMatches());
+ assertTrue("maybe matches A", ex.matchesFieldGet(x, foo).maybeMatches());
+ assertFalse("maybe matches A", ex.matchesFieldGet(x, foo).alwaysMatches());
// args - no args at get join point
ex = p.parsePointcutExpression("args(int)");
- assertTrue("matches x",ex.matchesFieldGet(x,a).neverMatches());
+ assertTrue("matches x", ex.matchesFieldGet(x, a).neverMatches());
// within
ex = p.parsePointcutExpression("within(*..A)");
- assertTrue("Matches in class A",ex.matchesFieldGet(x,a).alwaysMatches());
- assertTrue("Does not match in class B",ex.matchesFieldGet(x,b).neverMatches());
+ assertTrue("Matches in class A", ex.matchesFieldGet(x, a).alwaysMatches());
+ assertTrue("Does not match in class B", ex.matchesFieldGet(x, b).neverMatches());
// withincode
ex = p.parsePointcutExpression("withincode(* a*(..))");
- assertTrue("Should match",ex.matchesFieldGet(x,aa).alwaysMatches());
- assertTrue("Should not match",ex.matchesFieldGet(x,b).neverMatches());
+ assertTrue("Should match", ex.matchesFieldGet(x, aa).alwaysMatches());
+ assertTrue("Should not match", ex.matchesFieldGet(x, b).neverMatches());
}
-
+
public void testArgsMatching() {
// too few args
PointcutExpression ex = p.parsePointcutExpression("args(*,*,*,*)");
- assertTrue("Too few args",ex.matchesMethodExecution(foo).neverMatches());
- assertTrue("Matching #args",ex.matchesMethodExecution(bar).alwaysMatches());
+ assertTrue("Too few args", ex.matchesMethodExecution(foo).neverMatches());
+ assertTrue("Matching #args", ex.matchesMethodExecution(bar).alwaysMatches());
// one too few + ellipsis
ex = p.parsePointcutExpression("args(*,*,*,..)");
- assertTrue("Matches with ellipsis",ex.matchesMethodExecution(foo).alwaysMatches());
+ assertTrue("Matches with ellipsis", ex.matchesMethodExecution(foo).alwaysMatches());
// exact number + ellipsis
- assertTrue("Matches with ellipsis",ex.matchesMethodExecution(bar).alwaysMatches());
- assertTrue("Does not match with ellipsis",ex.matchesMethodExecution(a).neverMatches());
+ assertTrue("Matches with ellipsis", ex.matchesMethodExecution(bar).alwaysMatches());
+ assertTrue("Does not match with ellipsis", ex.matchesMethodExecution(a).neverMatches());
// too many + ellipsis
ex = p.parsePointcutExpression("args(*,..,*)");
- assertTrue("Matches with ellipsis",ex.matchesMethodExecution(bar).alwaysMatches());
- assertTrue("Does not match with ellipsis",ex.matchesMethodExecution(a).neverMatches());
- assertTrue("Matches with ellipsis",ex.matchesMethodExecution(aaa).alwaysMatches());
+ assertTrue("Matches with ellipsis", ex.matchesMethodExecution(bar).alwaysMatches());
+ assertTrue("Does not match with ellipsis", ex.matchesMethodExecution(a).neverMatches());
+ assertTrue("Matches with ellipsis", ex.matchesMethodExecution(aaa).alwaysMatches());
// exact match
ex = p.parsePointcutExpression("args(String,int,Number)");
- assertTrue("Matches exactly",ex.matchesMethodExecution(foo).alwaysMatches());
+ assertTrue("Matches exactly", ex.matchesMethodExecution(foo).alwaysMatches());
// maybe match
ex = p.parsePointcutExpression("args(String,int,Double)");
- assertTrue("Matches maybe",ex.matchesMethodExecution(foo).maybeMatches());
- assertFalse("Matches maybe",ex.matchesMethodExecution(foo).alwaysMatches());
+ assertTrue("Matches maybe", ex.matchesMethodExecution(foo).maybeMatches());
+ assertFalse("Matches maybe", ex.matchesMethodExecution(foo).alwaysMatches());
// never match
ex = p.parsePointcutExpression("args(String,Integer,Number)");
if (LangUtil.is15VMOrGreater()) {
- assertTrue("matches",ex.matchesMethodExecution(foo).alwaysMatches());
+ assertTrue("matches", ex.matchesMethodExecution(foo).alwaysMatches());
} else {
- assertTrue("Does not match",ex.matchesMethodExecution(foo).neverMatches());
+ assertTrue("Does not match", ex.matchesMethodExecution(foo).neverMatches());
}
}
-
-// public void testMatchesDynamically() {
-// // everything other than this,target,args should just return true
-// PointcutExpression ex = p.parsePointcutExpression("call(* *.*(..)) && execution(* *.*(..)) &&" +
-// "get(* *) && set(* *) && initialization(new(..)) && preinitialization(new(..)) &&" +
-// "staticinitialization(X) && adviceexecution() && within(Y) && withincode(* *.*(..)))");
-// assertTrue("Matches dynamically",ex.matchesDynamically(a,b,new Object[0]));
-// // this
-// ex = p.parsePointcutExpression("this(String)");
-// assertTrue("String matches",ex.matchesDynamically("",this,new Object[0]));
-// assertFalse("Object doesn't match",ex.matchesDynamically(new Object(),this,new Object[0]));
-// ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
-// assertTrue("A matches",ex.matchesDynamically(new A(""),this,new Object[0]));
-// assertTrue("B matches",ex.matchesDynamically(new B(""),this,new Object[0]));
-// // target
-// ex = p.parsePointcutExpression("target(String)");
-// assertTrue("String matches",ex.matchesDynamically(this,"",new Object[0]));
-// assertFalse("Object doesn't match",ex.matchesDynamically(this,new Object(),new Object[0]));
-// ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
-// assertTrue("A matches",ex.matchesDynamically(this,new A(""),new Object[0]));
-// assertTrue("B matches",ex.matchesDynamically(this,new B(""),new Object[0]));
-// // args
-// ex = p.parsePointcutExpression("args(*,*,*,*)");
-// assertFalse("Too few args",ex.matchesDynamically(null,null,new Object[]{a,b}));
-// assertTrue("Matching #args",ex.matchesDynamically(null,null,new Object[]{a,b,aa,aaa}));
-// // one too few + ellipsis
-// ex = p.parsePointcutExpression("args(*,*,*,..)");
-// assertTrue("Matches with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b,aa,aaa}));
-// // exact number + ellipsis
-// assertTrue("Matches with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b,aa}));
-// assertFalse("Does not match with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b}));
-// // too many + ellipsis
-// ex = p.parsePointcutExpression("args(*,..,*)");
-// assertTrue("Matches with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b,aa,aaa}));
-// assertFalse("Does not match with ellipsis",ex.matchesDynamically(null,null,new Object[]{a}));
-// assertTrue("Matches with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b}));
-// // exact match
-// ex = p.parsePointcutExpression("args(String,int,Number)");
-// assertTrue("Matches exactly",ex.matchesDynamically(null,null,new Object[]{"",new Integer(5),new Double(5.0)}));
-// ex = p.parsePointcutExpression("args(String,Integer,Number)");
-// assertTrue("Matches exactly",ex.matchesDynamically(null,null,new Object[]{"",new Integer(5),new Double(5.0)}));
-// // never match
-// ex = p.parsePointcutExpression("args(String,Integer,Number)");
-// assertFalse("Does not match",ex.matchesDynamically(null,null,new Object[]{a,b,aa}));
-//}
+
+ // public void testMatchesDynamically() {
+ // // everything other than this,target,args should just return true
+ // PointcutExpression ex = p.parsePointcutExpression("call(* *.*(..)) && execution(* *.*(..)) &&" +
+ // "get(* *) && set(* *) && initialization(new(..)) && preinitialization(new(..)) &&" +
+ // "staticinitialization(X) && adviceexecution() && within(Y) && withincode(* *.*(..)))");
+ // assertTrue("Matches dynamically",ex.matchesDynamically(a,b,new Object[0]));
+ // // this
+ // ex = p.parsePointcutExpression("this(String)");
+ // assertTrue("String matches",ex.matchesDynamically("",this,new Object[0]));
+ // assertFalse("Object doesn't match",ex.matchesDynamically(new Object(),this,new Object[0]));
+ // ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
+ // assertTrue("A matches",ex.matchesDynamically(new A(""),this,new Object[0]));
+ // assertTrue("B matches",ex.matchesDynamically(new B(""),this,new Object[0]));
+ // // target
+ // ex = p.parsePointcutExpression("target(String)");
+ // assertTrue("String matches",ex.matchesDynamically(this,"",new Object[0]));
+ // assertFalse("Object doesn't match",ex.matchesDynamically(this,new Object(),new Object[0]));
+ // ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
+ // assertTrue("A matches",ex.matchesDynamically(this,new A(""),new Object[0]));
+ // assertTrue("B matches",ex.matchesDynamically(this,new B(""),new Object[0]));
+ // // args
+ // ex = p.parsePointcutExpression("args(*,*,*,*)");
+ // assertFalse("Too few args",ex.matchesDynamically(null,null,new Object[]{a,b}));
+ // assertTrue("Matching #args",ex.matchesDynamically(null,null,new Object[]{a,b,aa,aaa}));
+ // // one too few + ellipsis
+ // ex = p.parsePointcutExpression("args(*,*,*,..)");
+ // assertTrue("Matches with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b,aa,aaa}));
+ // // exact number + ellipsis
+ // assertTrue("Matches with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b,aa}));
+ // assertFalse("Does not match with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b}));
+ // // too many + ellipsis
+ // ex = p.parsePointcutExpression("args(*,..,*)");
+ // assertTrue("Matches with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b,aa,aaa}));
+ // assertFalse("Does not match with ellipsis",ex.matchesDynamically(null,null,new Object[]{a}));
+ // assertTrue("Matches with ellipsis",ex.matchesDynamically(null,null,new Object[]{a,b}));
+ // // exact match
+ // ex = p.parsePointcutExpression("args(String,int,Number)");
+ // assertTrue("Matches exactly",ex.matchesDynamically(null,null,new Object[]{"",new Integer(5),new Double(5.0)}));
+ // ex = p.parsePointcutExpression("args(String,Integer,Number)");
+ // assertTrue("Matches exactly",ex.matchesDynamically(null,null,new Object[]{"",new Integer(5),new Double(5.0)}));
+ // // never match
+ // ex = p.parsePointcutExpression("args(String,Integer,Number)");
+ // assertFalse("Does not match",ex.matchesDynamically(null,null,new Object[]{a,b,aa}));
+ // }
public void testGetPointcutExpression() {
PointcutExpression ex = p.parsePointcutExpression("staticinitialization(*..A+)");
- assertEquals("staticinitialization(*..A+)",ex.getPointcutExpression());
+ assertEquals("staticinitialization(*..A+)", ex.getPointcutExpression());
}
-
+
public void testCouldMatchJoinPointsInType() {
PointcutExpression ex = p.parsePointcutExpression("execution(* org.aspectj.weaver.tools.PointcutExpressionTest.B.*(..))");
- assertTrue("Could maybe match String (as best we know at this point)",ex.couldMatchJoinPointsInType(String.class));
- assertTrue("Will always match B",ex.couldMatchJoinPointsInType(B.class));
+ assertFalse("Could maybe match String (as best we know at this point)", ex.couldMatchJoinPointsInType(String.class));
+ assertTrue("Will always match B", ex.couldMatchJoinPointsInType(B.class));
ex = p.parsePointcutExpression("within(org.aspectj.weaver.tools.PointcutExpressionTest.B)");
- assertFalse("Will never match String",ex.couldMatchJoinPointsInType(String.class));
- assertTrue("Will always match B",ex.couldMatchJoinPointsInType(B.class));
+ assertFalse("Will never match String", ex.couldMatchJoinPointsInType(String.class));
+ assertTrue("Will always match B", ex.couldMatchJoinPointsInType(B.class));
}
-
+
public void testMayNeedDynamicTest() {
PointcutExpression ex = p.parsePointcutExpression("execution(* org.aspectj.weaver.tools.PointcutExpressionTest.B.*(..))");
- assertFalse("No dynamic test needed",ex.mayNeedDynamicTest());
- ex = p.parsePointcutExpression("execution(* org.aspectj.weaver.tools.PointcutExpressionTest.B.*(..)) && args(org.aspectj.weaver.tools.PointcutExpressionTest.X)");
- assertTrue("Dynamic test needed",ex.mayNeedDynamicTest());
+ assertFalse("No dynamic test needed", ex.mayNeedDynamicTest());
+ ex = p
+ .parsePointcutExpression("execution(* org.aspectj.weaver.tools.PointcutExpressionTest.B.*(..)) && args(org.aspectj.weaver.tools.PointcutExpressionTest.X)");
+ assertTrue("Dynamic test needed", ex.mayNeedDynamicTest());
}
protected void setUp() throws Exception {
super.setUp();
- p = PointcutParser.getPointcutParserSupportingAllPrimitivesAndUsingSpecifiedClassloaderForResolution(this.getClass().getClassLoader());
- asCons = A.class.getConstructor(new Class[]{String.class});
+ p = PointcutParser.getPointcutParserSupportingAllPrimitivesAndUsingSpecifiedClassloaderForResolution(this.getClass()
+ .getClassLoader());
+ asCons = A.class.getConstructor(new Class[] { String.class });
bsCons = B.class.getConstructor(new Class[0]);
- bsStringCons = B.class.getConstructor(new Class[]{String.class});
- a = A.class.getMethod("a",new Class[0]);
- aa = A.class.getMethod("aa",new Class[]{int.class});
- aaa = A.class.getMethod("aaa",new Class[]{String.class,int.class});
+ bsStringCons = B.class.getConstructor(new Class[] { String.class });
+ a = A.class.getMethod("a", new Class[0]);
+ aa = A.class.getMethod("aa", new Class[] { int.class });
+ aaa = A.class.getMethod("aaa", new Class[] { String.class, int.class });
x = A.class.getDeclaredField("x");
y = B.class.getDeclaredField("y");
- b = B.class.getMethod("b",new Class[0]);
- bsaa = B.class.getMethod("aa",new Class[]{int.class});
+ b = B.class.getMethod("b", new Class[0]);
+ bsaa = B.class.getMethod("aa", new Class[] { int.class });
clientCons = Client.class.getConstructor(new Class[0]);
n = Client.class.getDeclaredField("n");
- foo = Client.class.getDeclaredMethod("foo",new Class[]{String.class,int.class,Number.class});
- bar = Client.class.getDeclaredMethod("bar",new Class[]{String.class,int.class,Integer.class,Number.class});
+ foo = Client.class.getDeclaredMethod("foo", new Class[] { String.class, int.class, Number.class });
+ bar = Client.class.getDeclaredMethod("bar", new Class[] { String.class, int.class, Integer.class, Number.class });
}
-
+
static class A {
- public A(String s) {}
- public void a() {}
- public void aa(int i) {}
- public void aaa(String s, int i) {}
- int x;
+ public A(String s) {
+ }
+
+ public void a() {
+ }
+
+ public void aa(int i) {
+ }
+
+ public void aaa(String s, int i) {
+ }
+
+ int x;
}
-
+
static class B extends A {
- public B() {super("");}
- public B(String s) {super(s);}
- public String b() { return null; }
- public void aa(int i) {}
+ public B() {
+ super("");
+ }
+
+ public B(String s) {
+ super(s);
+ }
+
+ public String b() {
+ return null;
+ }
+
+ public void aa(int i) {
+ }
+
int y;
}
-
+
static class Client {
- public Client() {}
+ public Client() {
+ }
+
Number n;
- public void foo(String s, int i, Number n) {}
- public void bar(String s, int i, Integer i2, Number n) {}
+
+ public void foo(String s, int i, Number n) {
+ }
+
+ public void bar(String s, int i, Integer i2, Number n) {
+ }
}
-
- static class X {}
-
+
+ static class X {
+ }
+
}
projects / aspectj.git / commitdiff