From: aclement Date: Wed, 10 Dec 2008 20:01:33 +0000 (+0000) Subject: some annotation matching tests X-Git-Tag: V1_6_3rc1~24 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=1c5d4bc331f4273083b547923b122571b8387bfe;p=aspectj.git some annotation matching tests --- diff --git a/org.aspectj.matcher/.classpath b/org.aspectj.matcher/.classpath index 856780f91..544d974e4 100644 --- a/org.aspectj.matcher/.classpath +++ b/org.aspectj.matcher/.classpath @@ -8,5 +8,6 @@ + diff --git a/org.aspectj.matcher/src/org/aspectj/weaver/reflect/StandardShadow.java b/org.aspectj.matcher/src/org/aspectj/weaver/reflect/StandardShadow.java index 411ccdd91..9a750481a 100644 --- a/org.aspectj.matcher/src/org/aspectj/weaver/reflect/StandardShadow.java +++ b/org.aspectj.matcher/src/org/aspectj/weaver/reflect/StandardShadow.java @@ -103,7 +103,6 @@ public class StandardShadow extends Shadow { ResolvedMember[] members = forType.getDeclaredMethods(); int clinit = -1; for (int i = 0; i < members.length && clinit == -1; i++) { - System.out.println(members[i]); if (members[i].getName().equals("")) { clinit = i; } 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 eee063f0f..226ae8b78 100644 --- a/org.aspectj.matcher/src/org/aspectj/weaver/tools/StandardPointcutParser.java +++ b/org.aspectj.matcher/src/org/aspectj/weaver/tools/StandardPointcutParser.java @@ -237,6 +237,7 @@ public class StandardPointcutParser { } catch (ParserException pEx) { throw new IllegalArgumentException(buildUserMessageFromParserException(expression, pEx)); } catch (ReflectionWorld.ReflectionWorldException rwEx) { + rwEx.printStackTrace(); throw new IllegalArgumentException(rwEx.getMessage()); } return pcExpr; diff --git a/org.aspectj.matcher/testdata/AnnotatedClass.java b/org.aspectj.matcher/testdata/AnnotatedClass.java new file mode 100644 index 000000000..80dbda413 --- /dev/null +++ b/org.aspectj.matcher/testdata/AnnotatedClass.java @@ -0,0 +1,11 @@ +package testdata; + +@SomeAnnotation +public class AnnotatedClass { + + @MethodLevelAnnotation + public void annotatedMethod() { } + + public void nonAnnotatedMethod() { + } +} diff --git a/org.aspectj.matcher/testdata/MethodLevelAnnotation.java b/org.aspectj.matcher/testdata/MethodLevelAnnotation.java new file mode 100644 index 000000000..2f46dd8ab --- /dev/null +++ b/org.aspectj.matcher/testdata/MethodLevelAnnotation.java @@ -0,0 +1,5 @@ +package testdata; +import java.lang.annotation.*; + +@Retention(RetentionPolicy.RUNTIME) +@interface MethodLevelAnnotation {} diff --git a/org.aspectj.matcher/testdata/SomeAnnotation.java b/org.aspectj.matcher/testdata/SomeAnnotation.java new file mode 100644 index 000000000..25a4991d6 --- /dev/null +++ b/org.aspectj.matcher/testdata/SomeAnnotation.java @@ -0,0 +1,6 @@ +package testdata; + +import java.lang.annotation.*; + +@Retention(RetentionPolicy.RUNTIME) +@interface SomeAnnotation {} diff --git a/org.aspectj.matcher/testdata/testdata.jar b/org.aspectj.matcher/testdata/testdata.jar new file mode 100644 index 000000000..7bbb39068 Binary files /dev/null and b/org.aspectj.matcher/testdata/testdata.jar differ diff --git a/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonAdvancedPointcutExpressionTests.java b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonAdvancedPointcutExpressionTests.java new file mode 100644 index 000000000..e5fa8b0c0 --- /dev/null +++ b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonAdvancedPointcutExpressionTests.java @@ -0,0 +1,695 @@ +/******************************************************************************* + * 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.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). These tests require some testdata types. + * + * This is based on the Reflection oriented PointcutExpressionTest in the weaver project. + * + * TESTDATA. The testdata for these tests is kept in org.aspectj.matcher/testdata. It is a series of .java files that need to be + * compiled and available at runtime. Since they are java5 (they include annotations) they cannot be in a source folder for the + * project, so they are compiled separately and then jar'd into a testdata.jar file in that folder. This folder is defined to be on + * the classpath for org.aspectj.matcher, this enables them to be seen by a simple world that uses the classpath of the matcher + * project as the definition of what it can see. Other worlds, for example JDT World, will need to have those types defined in a + * project that is accessible in the JDT World instance. Because these tests exercise Java5 matching, the concrete ReflectionWorld + * subtype is not defined in here, it is defined in weaver5 (messy, but works well). + * + * @author Andy Clement + */ +public abstract class CommonAdvancedPointcutExpressionTests 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() { + assertFalse(world.resolve("testdata.SomeAnnotation").isMissing()); + assertFalse(world.resolve("testdata.MethodLevelAnnotation").isMissing()); + assertFalse(world.resolve("testdata.AnnotatedClass").isMissing()); + } + + public void testTypeLevelAnnotationMatchingWithStaticInitialization01() { + StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("staticinitialization(@testdata.SomeAnnotation *)"); + ResolvedType jlString = world.resolve("java.lang.String"); + ResolvedType tAnnotatedClass = world.resolve("testdata.AnnotatedClass"); + + assertTrue(ex.matchesStaticInitialization(tAnnotatedClass).alwaysMatches()); + assertTrue(ex.matchesStaticInitialization(jlString).neverMatches()); + } + + public void testTypeLevelAnnotationMatchingWithExecution01() { + StandardPointcutExpression ex = pointcutParser.parsePointcutExpression("execution(* (@testdata.SomeAnnotation *).*(..))"); + ResolvedType jlString = world.resolve("java.lang.String"); + ResolvedType tAnnotatedClass = world.resolve("testdata.AnnotatedClass"); + assertTrue(ex.matchesMethodExecution(getMethod(tAnnotatedClass, "annotatedMethod", "()V")).alwaysMatches()); + assertTrue(ex.matchesMethodExecution(getMethod(jlString, "valueOf", "(Z)Ljava/lang/String;")).neverMatches()); + } + + public void testMethodLevelAnnotationMatchingWithExecution01() { + StandardPointcutExpression ex = pointcutParser + .parsePointcutExpression("execution(@testdata.MethodLevelAnnotation * *(..))"); + ResolvedType jlString = world.resolve("java.lang.String"); + ResolvedType tAnnotatedClass = world.resolve("testdata.AnnotatedClass"); + assertTrue(ex.matchesMethodExecution(getMethod(tAnnotatedClass, "annotatedMethod", "()V")).alwaysMatches()); + assertTrue(ex.matchesMethodExecution(getMethod(tAnnotatedClass, "nonAnnotatedMethod", "()V")).neverMatches()); + assertTrue(ex.matchesMethodExecution(getMethod(jlString, "valueOf", "(Z)Ljava/lang/String;")).neverMatches()); + } + + // + // ResolvedMember stringSplitMethod = getMethod(jlString, "split", "(Ljava/lang/String;I)[Ljava/lang/String;"); + // ResolvedMember stringValueOfIntMethod = getMethod(jlString, "valueOf", "(I)Ljava/lang/String;"); + // ResolvedMember listAddMethod = getMethod(juList, "add", "(Ljava/lang/Object;)Z"); + + // 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); + // } + + // public void testMethodExecutionMatching04() { + // 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/FurtherCommonPointcutExpressionTests.java b/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/FurtherCommonPointcutExpressionTests.java deleted file mode 100644 index 03860c008..000000000 --- a/org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/FurtherCommonPointcutExpressionTests.java +++ /dev/null @@ -1,658 +0,0 @@ -/******************************************************************************* - * 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.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). These tests require some testdata types. - * - * This is based on the Reflection oriented PointcutExpressionTest in the weaver project. - * - * @author Andy Clement - */ -public abstract class FurtherCommonPointcutExpressionTests 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); - // } - - // public void testMethodExecutionMatching04() { - // 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); - } - -}