few more tests added

diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/tools/StandardPointcutParser.java b/org.aspectj.matcher/src/org/aspectj/weaver/tools/StandardPointcutParser.java
index 226ae8b78350e7158139b67ddf100311397b9dd1..ae6b3fdf27a482e8e652f107a9d9a5e3a480913b 100644 (file)
--- a/org.aspectj.matcher/src/org/aspectj/weaver/tools/StandardPointcutParser.java
+++ b/org.aspectj.matcher/src/org/aspectj/weaver/tools/StandardPointcutParser.java
@@ -314,7 +314,9 @@ public class StandardPointcutParser {
                        formalBindings[i] = new FormalBinding(toUnresolvedType(formalParameters[i].getType()), formalParameters[i].getName(), i);
                }
                if (inScope == null) {
-                       return new SimpleScope(getWorld(), formalBindings);
+                       SimpleScope ss = new SimpleScope(getWorld(), formalBindings);
+                       ss.setImportedPrefixes(new String[] { "java.lang.", "java.util." });
+                       return ss;
                } else {
                        ResolvedType inType = getWorld().resolve(inScope.getName());
                        ISourceContext sourceContext = new ISourceContext() {
@@ -333,7 +335,9 @@ public class StandardPointcutParser {
                                public void tidy() {
                                }
                        };
-                       return new BindingScope(inType, sourceContext, formalBindings);
+                       BindingScope bScope = new BindingScope(inType, sourceContext, formalBindings);
+                       bScope.setImportedPrefixes(new String[] { "java.lang.", "java.util." });
+                       return bScope;
                }
        }
 

diff --git a/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonPointcutExpressionTests.java b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonPointcutExpressionTests.java
index c67fe348f867624eec78dc1f9ee5f577581b7121..8fccfbf997574e01e2ed61e652bb83b24b4dc32a 100644 (file)
--- a/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonPointcutExpressionTests.java
+++ b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonPointcutExpressionTests.java
@@ -85,6 +85,58 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
                checkAlwaysMatches("execution(*b*[] *())", "java.util.List", "toArray", "()[Ljava/lang/Object;");
        }
 
+       public void testConstructorExecutionMatching01() {
+               checkAlwaysMatches("execution(new())", "java.lang.String", "<init>", "()V");
+       }
+
+       public void testConstructorExecutionMatching02() {
+               checkAlwaysMatches("execution(new(char[]))", "java.lang.String", "<init>", "([C)V");
+               checkAlwaysMatches("execution(new(..))", "java.lang.String", "<init>", "()V");
+               checkAlwaysMatches("execution(new(..))", "java.lang.String", "<init>", "(Ljava/lang/String;)V");
+               checkAlwaysMatches("execution(new(*))", "java.lang.String", "<init>", "(Ljava/lang/String;)V");
+               checkNeverMatches("execution(new(*))", "java.lang.String", "<init>", "()V");
+               checkAlwaysMatches("execution(new(*,*,*))", "java.lang.String", "<init>", "([CII)V");
+               checkAlwaysMatches("execution(new(*,int,*))", "java.lang.String", "<init>", "([III)V");
+               checkNeverMatches("execution(new(..,int[]))", "java.lang.String", "<init>", "([III)V");
+       }
+
+       public void testConstructorExecutionMatching03() {
+
+               ResolvedType jlArrayList = world.resolve("java.util.ArrayList");
+               ResolvedType juList = world.resolve("java.util.List");
+
+               StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("execution(java.util.ArrayList.new(..))");
+               assertNotNull(ex);
+
+               // simple constructor
+               ShadowMatch shadowMatch = ex.matchesMethodExecution(getMethod(jlArrayList, "<init>", "()V"));
+               assertTrue(shadowMatch.alwaysMatches());
+
+               ex = pointcutParser.parsePointcutExpression("execution(ArrayList.new(..))");
+               shadowMatch = ex.matchesMethodExecution(getMethod(jlArrayList, "<init>", "()V"));
+               assertTrue(shadowMatch.alwaysMatches());
+
+               ex = pointcutParser.parsePointcutExpression("execution(*Arr*.new(..))");
+               shadowMatch = ex.matchesMethodExecution(getMethod(jlArrayList, "<init>", "()V"));
+               assertTrue(shadowMatch.alwaysMatches());
+
+               ex = pointcutParser.parsePointcutExpression("execution(java.util.*.new(..))");
+               shadowMatch = ex.matchesMethodExecution(getMethod(jlArrayList, "<init>", "()V"));
+               assertTrue(shadowMatch.alwaysMatches());
+
+               ex = pointcutParser.parsePointcutExpression("execution(java.*.new(..))");
+               shadowMatch = ex.matchesMethodExecution(getMethod(jlArrayList, "<init>", "()V"));
+               assertTrue(shadowMatch.neverMatches());
+
+               ex = pointcutParser.parsePointcutExpression("execution(java..*.new(..))");
+               shadowMatch = ex.matchesMethodExecution(getMethod(jlArrayList, "<init>", "()V"));
+               assertTrue(shadowMatch.alwaysMatches());
+
+               ex = pointcutParser.parsePointcutExpression("execution(*..ArrayList.new(..))");
+               shadowMatch = ex.matchesMethodExecution(getMethod(jlArrayList, "<init>", "()V"));
+               assertTrue(shadowMatch.alwaysMatches());
+       }
+
        public void testMatchingThis01() {
                StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("this(java.lang.String)");
                ResolvedType jlString = world.resolve("java.lang.String");
@@ -199,6 +251,25 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
                assertTrue(ex.matchesMethodCall(listAddMethod, stringSplitMethod).neverMatches());
        }
 
+       public void testCall() {
+               StandardPointcutExpression ex = pointcutParser.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());
+       }
+
        public void testCallAndThisMatchesMethodCall() {
                StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("call(* *(..)) && this(java.util.ArrayList)");
                ResolvedType jlString = world.resolve("java.lang.String");
@@ -212,22 +283,6 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
                assertTrue(ex.matchesMethodCall(stringSplitMethod, listAddMethod).maybeMatches());
        }
 
-       // 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());
@@ -294,14 +349,6 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
        // 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)");
@@ -404,7 +451,7 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
        // }
        // -- next few tests relate to matching different pointcut expressions against a staticinitialization join point
 
-       public void testMethodMatchesStaticInitialization() {
+       public void testMethodMatchesStaticInitialization01() {
                StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("staticinitialization(java.lang.String)");
                assertNotNull(ex);
 
@@ -414,6 +461,28 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
                assertTrue(b);
        }
 
+       public void testMethodMatchesStaticInitialization02() {
+               ResolvedType jlString = world.resolve("java.lang.String");
+               StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("staticinitialization(java..*)");
+               assertTrue(ex.matchesStaticInitialization(jlString).alwaysMatches());
+               ex = pointcutParser.parsePointcutExpression("staticinitialization(java..*)");
+               assertTrue(ex.matchesStaticInitialization(jlString).alwaysMatches());
+               ex = pointcutParser.parsePointcutExpression("staticinitialization(java.*)");
+               assertTrue(ex.matchesStaticInitialization(jlString).neverMatches());
+       }
+
+       public void testMethodMatchesStaticInitialization03() {
+               ResolvedType juArrayList = world.resolve("java.util.ArrayList");
+               StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("staticinitialization(java..*)");
+               assertTrue(ex.matchesStaticInitialization(juArrayList).alwaysMatches());
+               ex = pointcutParser.parsePointcutExpression("staticinitialization(java.util.ArrayList)");
+               assertTrue(ex.matchesStaticInitialization(juArrayList).alwaysMatches());
+               ex = pointcutParser.parsePointcutExpression("staticinitialization(java.util.List+)");
+               assertTrue(ex.matchesStaticInitialization(juArrayList).alwaysMatches());
+               ex = pointcutParser.parsePointcutExpression("staticinitialization(List)");
+               assertTrue(ex.matchesStaticInitialization(juArrayList).neverMatches());
+       }
+
        //
        // public void testMatchesInitialization() {
        // PointcutExpression ex = p.parsePointcutExpression("initialization(new(String))");
@@ -481,11 +550,6 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
        // }
        //
        // 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());
@@ -675,6 +739,7 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
        private ResolvedMember getMethod(ResolvedType type, String methodName, String methodSignature) {
                ResolvedMember[] methods = type.getDeclaredMethods();
                for (int i = 0; i < methods.length; i++) {
+                       System.out.println(methods[i].getName() + methods[i].getSignature());
                        if (methods[i].getName().equals(methodName)
                                        && (methodSignature == null || methodSignature.equals(methods[i].getSignature()))) {
                                return methods[i];
@@ -688,9 +753,9 @@ public abstract class CommonPointcutExpressionTests extends TestCase {
                assertNotNull(ex);
                ResolvedType resolvedType = world.resolve(type);
                ResolvedMember method = getMethod(resolvedType, methodName, methodSignature);
-               assertNotNull(method);
+               assertNotNull("Couldn't find a method with signature " + methodSignature, method);
                boolean b = ex.matchesMethodExecution(method).alwaysMatches();
-               assertTrue(b);
+               assertTrue("Match failed", b);
        }
 
        private void checkNeverMatches(String pointcutExpression, String type, String methodName, String methodSignature) {