From: aclement Date: Sun, 8 Nov 2009 22:56:16 +0000 (+0000) Subject: fastmatch for execution! X-Git-Tag: V1_6_7~118 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=bf851c2e6899f40554341b4e9d3b7a3ddf966b09;p=aspectj.git fastmatch for execution! --- diff --git a/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java b/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java index 5b97d8986..75a039a27 100644 --- a/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java +++ b/weaver/src/org/aspectj/weaver/bcel/AtAjAttributes.java @@ -779,10 +779,14 @@ public class AtAjAttributes { // then iterate on field interface hierarchy (not object) boolean hasAtLeastOneMethod = false; - ResolvedMember[] methods = fieldType.getMethodsWithoutIterator(true, false, false).toArray( - new ResolvedMember[0]); - for (int i = 0; i < methods.length; i++) { - ResolvedMember method = methods[i]; + Iterator methodIterator = fieldType.getMethodsIncludingIntertypeDeclarations(false, true); + while (methodIterator.hasNext()) { + ResolvedMember method = methodIterator.next(); + + // ResolvedMember[] methods = fieldType.getMethodsWithoutIterator(true, false, false).toArray( + // new ResolvedMember[0]); + // for (int i = 0; i < methods.length; i++) { + // ResolvedMember method = methods[i]; if (method.isAbstract()) { // moved to be detected at weave time if the target // doesnt implement the methods diff --git a/weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java b/weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java index 6aba253d6..9bb4cb266 100644 --- a/weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java +++ b/weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java @@ -231,7 +231,6 @@ public class BcelObjectType extends AbstractReferenceTypeDelegate { return supertype; } - public World getWorld() { return getResolvedTypeX().getWorld(); } @@ -259,12 +258,6 @@ public class BcelObjectType extends AbstractReferenceTypeDelegate { } else { interfaceTypes = new ResolvedType[interfaceSignatures.length]; for (int i = 0, len = interfaceSignatures.length; i < len; i++) { - if (interfaceSignatures[i] == null) { // debug for NPE - String msg = "Null interface signature (element:" + i + " of " + interfaceSignatures.length - + "). Type for which we" + "are looking at interfaces is " + this.className + "."; - System.err.println(msg); - throw new BCException(msg); - } interfaceTypes[i] = getResolvedTypeX().getWorld().resolve(UnresolvedType.forSignature(interfaceSignatures[i])); } } diff --git a/weaver/testsrc/org/aspectj/weaver/tools/PointcutExpressionTest.java b/weaver/testsrc/org/aspectj/weaver/tools/PointcutExpressionTest.java index acd510f50..46189fd32 100644 --- a/weaver/testsrc/org/aspectj/weaver/tools/PointcutExpressionTest.java +++ b/weaver/testsrc/org/aspectj/weaver/tools/PointcutExpressionTest.java @@ -14,10 +14,10 @@ import java.lang.reflect.Constructor; 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; @@ -35,127 +35,127 @@ public class PointcutExpressionTest extends TestCase { 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() { @@ -164,405 +164,433 @@ public class PointcutExpressionTest extends TestCase { 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 { + } + }