fastmatch for execution!

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<ResolvedMember> 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

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]));
 			}
 		}

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 {
+	}
+
 }