split weaving/matching: pointcut matching tests

3 files changed, 678 insertions, 1 deletions

diff --git a/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonPointcutExpressionTests.java b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonPointcutExpressionTests.java
new file mode 100644
index 000000000..26e0e0b5c
--- /dev/null
+++ b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonPointcutExpressionTests.java
@@ -0,0 +1,659 @@
+/*******************************************************************************
+ * Copyright (c) 2008 Contributors
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ * 
+ * Contributors:
+ *     Andy Clement
+ *******************************************************************************/
+package org.aspectj.matcher.tools;
+
+import junit.framework.TestCase;
+
+import org.aspectj.weaver.ResolvedMember;
+import org.aspectj.weaver.ResolvedType;
+import org.aspectj.weaver.UnresolvedType;
+import org.aspectj.weaver.World;
+import org.aspectj.weaver.tools.StandardPointcutExpression;
+import org.aspectj.weaver.tools.StandardPointcutParser;
+
+/**
+ * Test the use of the pointcut parser and matching infrastructure. The org.aspectj.matcher.tools infrastructure used should not be
+ * aware of what kind of World it is working with and only operate in terms of the type abstraction expressed in the
+ * org.aspectj.matcher project (so Members, etc).
+ * 
+ * This is based on the Reflection oriented PointcutExpressionTest in the weaver project.
+ * 
+ * @author Andy Clement
+ */
+public abstract class CommonPointcutExpressionTests extends TestCase {
+
+	private World world;
+	private StandardPointcutParser pointcutParser;
+
+	protected abstract World getWorld();
+
+	protected void setUp() throws Exception {
+		super.setUp();
+		world = getWorld();
+		pointcutParser = StandardPointcutParser.getPointcutParserSupportingAllPrimitives(world);
+	}
+
+	public void testResolvingOneType() {
+		// do it via name
+		ResolvedType type = world.resolve("java.lang.String");
+		assertNotNull(type);
+		// do it via signature
+		type = world.resolve(UnresolvedType.forSignature("Ljava/lang/String;"));
+		assertNotNull(type);
+	}
+
+	public void testResolveTypeAndRetrieveMethod() {
+		ResolvedType type = world.resolve("java.lang.String");
+		assertNotNull(type);
+		ResolvedMember method = getMethod(type, "valueOf", "(Z)Ljava/lang/String;"); // grab the method 'String valueOf()'
+		assertNotNull(method);
+	}
+
+	public void testMethodExecutionMatching01() {
+		checkAlwaysMatches("execution(String valueOf(boolean))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+	}
+
+	public void testMethodExecutionMatching02() {
+		checkAlwaysMatches("execution(* *val*(..))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+		checkAlwaysMatches("execution(String *(..))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+		checkAlwaysMatches("execution(* *(boolean))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+		checkAlwaysMatches("execution(* j*..*.valueOf(..))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+		checkAlwaysMatches("execution(* *(*))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+
+		checkNeverMatches("execution(* vulueOf(..))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+		checkNeverMatches("execution(int *(..))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+		checkNeverMatches("execution(* valueOf(String))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+		checkNeverMatches("execution(private * valueOf(..))", "java.lang.String", "valueOf", "(Z)Ljava/lang/String;");
+	}
+
+	public void testMethodExecutionMatching03() {
+		checkAlwaysMatches("execution(* *())", "java.util.List", "toArray", "()[Ljava/lang/Object;");
+		checkAlwaysMatches("execution(*[] *())", "java.util.List", "toArray", "()[Ljava/lang/Object;");
+		checkAlwaysMatches("execution(*b*[] *())", "java.util.List", "toArray", "()[Ljava/lang/Object;");
+	}
+
+	// ---
+
+	public void testMethodMatchesStaticInitialization() {
+		StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("staticinitialization(java.lang.String)");
+		assertNotNull(ex);
+
+		ResolvedType jlString = world.resolve("java.lang.String");
+
+		boolean b = ex.matchesStaticInitialization(jlString).alwaysMatches();
+		assertTrue(b);
+
+		// was 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());
+		// ex = p.parsePointcutExpression("call(* *..A.a*(int))");
+		// 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());
+		// 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());
+		//
+		// // test target
+		// ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
+		// 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());
+		//
+		// // 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());
+		//
+		// // 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());
+		//
+		// // withincode
+		// ex = p.parsePointcutExpression("withincode(* a*(..))");
+		// assertTrue("Should not match", ex.matchesMethodExecution(a).neverMatches());
+	}
+
+	// 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());
+	// 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());
+	// 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());
+	// 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());
+	// ex = p.parsePointcutExpression("execution(* *.*(..))");
+	// 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());
+	// 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());
+	// // target
+	// ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
+	// 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());
+	// 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());
+	// // 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());
+	// // 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());
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// assertTrue("Should match", ex.matchesMethodCall(b, bsaa).alwaysMatches());
+	// assertTrue("Should not match", ex.matchesMethodCall(b, b).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());
+	// 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());
+	// // 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());
+	// 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());
+	// // target
+	// ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
+	// 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());
+	// // 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());
+	// // 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());
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// assertTrue("Should match", ex.matchesConstructorCall(bsCons, aa).alwaysMatches());
+	// assertTrue("Should not match", ex.matchesConstructorCall(bsCons, b).neverMatches());
+	// }
+	//
+	// public void testMatchesConstructorExecution() {
+	// PointcutExpression ex = p.parsePointcutExpression("execution(new(String))");
+	// 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());
+	// 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());
+	//
+	// // test this
+	// ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
+	// 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());
+	//
+	// // test target
+	// ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
+	// 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());
+	//
+	// // 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());
+	//
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// 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 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());
+	// // test this
+	// ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
+	// 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());
+	//
+	// // test target
+	// ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
+	// 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());
+	//
+	// // 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());
+	//
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// 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());
+	// }
+	//
+	// 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());
+	// // test this
+	// ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.Client)");
+	// 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());
+	// // 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());
+	// // 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());
+	// // 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());
+	// // 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());
+	// }
+	//
+	// public void testMatchesInitialization() {
+	// PointcutExpression ex = p.parsePointcutExpression("initialization(new(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());
+	// 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());
+	// 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());
+	//
+	// // test target
+	// ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
+	// 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());
+	// // 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());
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// 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());
+	// }
+	//
+	// public void testMatchesPreInitialization() {
+	// PointcutExpression ex = p.parsePointcutExpression("preinitialization(new(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());
+	// 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());
+	//
+	// // test target
+	// ex = p.parsePointcutExpression("target(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
+	// 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());
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// 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());
+	// }
+	//
+	// 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());
+	// // this
+	// ex = p.parsePointcutExpression("this(org.aspectj.weaver.tools.PointcutExpressionTest.A)");
+	// 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());
+	//
+	// // args
+	// ex = p.parsePointcutExpression("args()");
+	// assertTrue("No args", ex.matchesStaticInitialization(A.class).alwaysMatches());
+	// ex = p.parsePointcutExpression("args(String)");
+	// 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());
+	//
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// 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());
+	// // 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());
+	// 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());
+	// // 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());
+	// // 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());
+	// // 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());
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// 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());
+	// // 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());
+	// 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());
+	// // 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());
+	// // args - no args at get join point
+	// ex = p.parsePointcutExpression("args(int)");
+	// 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());
+	// // withincode
+	// ex = p.parsePointcutExpression("withincode(* a*(..))");
+	// 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());
+	// // one too few + ellipsis
+	// ex = p.parsePointcutExpression("args(*,*,*,..)");
+	// 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());
+	// // 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());
+	// // exact match
+	// ex = p.parsePointcutExpression("args(String,int,Number)");
+	// 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());
+	// // never match
+	// ex = p.parsePointcutExpression("args(String,Integer,Number)");
+	// if (LangUtil.is15VMOrGreater()) {
+	// assertTrue("matches", ex.matchesMethodExecution(foo).alwaysMatches());
+	// } else {
+	// 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 testGetPointcutExpression() {
+	// PointcutExpression ex = p.parsePointcutExpression("staticinitialization(*..A+)");
+	// 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));
+	// 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));
+	// }
+	//
+	// 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());
+	// }
+
+	// static class A {
+	// 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) {
+	// }
+	//
+	// int y;
+	// }
+	//
+	// static class 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) {
+	// }
+	// }
+	//
+	// static class X {
+	// }
+
+	private ResolvedMember getMethod(ResolvedType type, String methodName, String methodSignature) {
+		ResolvedMember[] methods = type.getDeclaredMethods();
+		for (int i = 0; i < methods.length; i++) {
+			if (methods[i].getName().equals(methodName)
+					&& (methodSignature == null || methodSignature.equals(methods[i].getSignature()))) {
+				return methods[i];
+			}
+		}
+		return null;
+	}
+
+	private void checkAlwaysMatches(String pointcutExpression, String type, String methodName, String methodSignature) {
+		StandardPointcutExpression ex = pointcutParser.parsePointcutExpression(pointcutExpression);
+		assertNotNull(ex);
+		ResolvedType resolvedType = world.resolve(type);
+		ResolvedMember method = getMethod(resolvedType, methodName, methodSignature);
+		assertNotNull(method);
+		boolean b = ex.matchesMethodExecution(method).alwaysMatches();
+		assertTrue(b);
+	}
+
+	private void checkNeverMatches(String pointcutExpression, String type, String methodName, String methodSignature) {
+		StandardPointcutExpression ex = pointcutParser.parsePointcutExpression(pointcutExpression);
+		assertNotNull(ex);
+		ResolvedType resolvedType = world.resolve(type);
+		ResolvedMember method = getMethod(resolvedType, methodName, methodSignature);
+		assertNotNull(method);
+		boolean b = ex.matchesMethodExecution(method).neverMatches();
+		assertTrue(b);
+	}
+}
diff --git a/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/ReflectionWorldPointcutExpressionTests.java b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/ReflectionWorldPointcutExpressionTests.java
new file mode 100644
index 000000000..1a5f9be43
--- /dev/null
+++ b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/ReflectionWorldPointcutExpressionTests.java
@@ -0,0 +1,17 @@
+package org.aspectj.matcher.tools;
+
+import org.aspectj.weaver.World;
+import org.aspectj.weaver.reflect.ReflectionWorld;
+
+/**
+ * Run all the pointcut parsing/matching tests against a ReflectionWorld.
+ * 
+ * @author Andy Clement
+ */
+public class ReflectionWorldPointcutExpressionTests extends CommonPointcutExpressionTests {
+
+	protected World getWorld() {
+		return new ReflectionWorld(true, getClass().getClassLoader());
+	}
+
+}
diff --git a/org.aspectj.matcher/testsrc/org/aspectj/weaver/MatcherModuleTests.java b/org.aspectj.matcher/testsrc/org/aspectj/weaver/MatcherModuleTests.java
index acb04c03f..5b646c5df 100644
--- a/org.aspectj.matcher/testsrc/org/aspectj/weaver/MatcherModuleTests.java
+++ b/org.aspectj.matcher/testsrc/org/aspectj/weaver/MatcherModuleTests.java
@@ -17,6 +17,7 @@ import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
+import org.aspectj.matcher.tools.ReflectionWorldPointcutExpressionTests;
 import org.aspectj.weaver.patterns.PatternsTests;
 import org.aspectj.weaver.reflect.ReflectionWorldBasicTest;
 import org.aspectj.weaver.reflect.ReflectionWorldSpecificTest;
@@ -31,8 +32,8 @@ public class MatcherModuleTests extends TestCase {
 		TestSuite suite = new TestSuite(MatcherModuleTests.class.getName());
 		suite.addTestSuite(ReflectionWorldSpecificTest.class);
 		suite.addTestSuite(ReflectionWorldBasicTest.class);
+		suite.addTestSuite(ReflectionWorldPointcutExpressionTests.class);
 		suite.addTest(PatternsTests.suite());
 		return suite;
 	}
-
 }