aboutsummaryrefslogtreecommitdiffstats
path: root/runtime/src/test
diff options
context:
space:
mode:
authorAndy Clement <aclement@pivotal.io>2019-01-24 12:36:00 -0800
committerAndy Clement <aclement@pivotal.io>2019-01-24 12:36:00 -0800
commit52c4cbfa1b8bcc0d2c7ac50c77203e516b335205 (patch)
tree37d1816978a683149f7bce63739968b2f343afe7 /runtime/src/test
parente01e4369b4c60775d679d8de678f54097fdc3120 (diff)
downloadaspectj-52c4cbfa1b8bcc0d2c7ac50c77203e516b335205.tar.gz
aspectj-52c4cbfa1b8bcc0d2c7ac50c77203e516b335205.zip
mavenizing runtime module - merged in aspectj5rt
Diffstat (limited to 'runtime/src/test')
-rw-r--r--runtime/src/test/java/org/aspectj/internal/lang/reflect/AjTypeTest.java327
-rw-r--r--runtime/src/test/java/org/aspectj/internal/lang/reflect/AjTypeWithAspectsTest.java449
-rw-r--r--runtime/src/test/java/org/aspectj/internal/lang/reflect/InterTypeTest.java88
3 files changed, 864 insertions, 0 deletions
diff --git a/runtime/src/test/java/org/aspectj/internal/lang/reflect/AjTypeTest.java b/runtime/src/test/java/org/aspectj/internal/lang/reflect/AjTypeTest.java
new file mode 100644
index 000000000..542de36d5
--- /dev/null
+++ b/runtime/src/test/java/org/aspectj/internal/lang/reflect/AjTypeTest.java
@@ -0,0 +1,327 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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://eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Adrian Colyer initial implementation
+ * ******************************************************************/
+package org.aspectj.internal.lang.reflect;
+
+import java.io.Serializable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+import junit.framework.TestCase;
+
+import org.aspectj.lang.reflect.AjType;
+import org.aspectj.lang.reflect.AjTypeSystem;
+
+public class AjTypeTest extends TestCase {
+
+ private AjType<String> stringType;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ stringType = AjTypeSystem.getAjType(String.class);
+ }
+
+ public void testCreateAjType() {
+ assertNotNull("should find type",stringType);
+ }
+
+ public void testGetName() {
+ assertEquals(String.class.getName(),stringType.getName());
+ }
+
+ public void testGetPackage() {
+ assertEquals(String.class.getPackage(),stringType.getPackage());
+ }
+
+ public void testGetInterfaces() {
+ Class[] i1 = String.class.getInterfaces();
+ AjType<?>[] i2 = stringType.getInterfaces();
+ assertEquals(i1.length,i2.length);
+ for (int i = 0; i < i1.length; i++)
+ assertEquals(i1[i],i2[i].getJavaClass());
+ }
+
+ public void testGetModifiers() {
+ assertEquals(String.class.getModifiers(),stringType.getModifiers());
+ }
+
+ public void testGetSupertype() {
+ Class<?> stringSuper = String.class.getSuperclass();
+ AjType ajSuper = stringType.getSupertype();
+ assertEquals(AjTypeSystem.getAjType(stringSuper),ajSuper);
+ }
+
+ public void testObjectSupertype() {
+ AjType<?> objectSuper = AjTypeSystem.getAjType(Object.class).getSupertype();
+ assertNull(objectSuper);
+ }
+
+ public void testInterfaceSupertype() {
+ AjType<?> serializableSuper = AjTypeSystem.getAjType(Serializable.class).getSupertype();
+ assertNull(serializableSuper);
+ }
+
+ public void testGetGenericSupertype() {
+ Type t = AjTypeSystem.getAjType(Goo.class).getGenericSupertype();
+ assertEquals(Foo.class,t);
+ }
+
+ public void testGetEnclosingMethod() {
+ new Goo().foo();
+ }
+
+ public void testGetEnclosingConstructor() {
+ new Goo();
+ }
+
+ public void testGetEnclosingType() {
+ AjType t = AjTypeSystem.getAjType(Foo.Z.class);
+ assertEquals("org.aspectj.internal.lang.reflect.Foo",t.getEnclosingType().getName());
+ }
+
+ public void testGetDeclaringType() {
+ AjType t = AjTypeSystem.getAjType(Foo.Z.class);
+ assertEquals("org.aspectj.internal.lang.reflect.Foo",t.getDeclaringType().getName());
+ }
+
+ public void testIsAnnotationPresent() {
+ AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+ AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+ assertTrue(foo.isAnnotationPresent(SomeAnn.class));
+ assertFalse(goo.isAnnotationPresent(SomeAnn.class));
+ }
+
+ public void testGetAnnotation() {
+ AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+ AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+ assertNotNull(foo.getAnnotation(SomeAnn.class));
+ assertNull(goo.getAnnotation(SomeAnn.class));
+ }
+
+ public void testGetAnnotations() {
+ AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+ AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+ assertEquals(1,foo.getAnnotations().length);
+ assertEquals(0,goo.getAnnotations().length);
+ }
+
+ public void testGetDeclaredAnnotations() {
+ AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+ AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+ assertEquals(0,goo.getDeclaredAnnotations().length);
+ assertEquals(1,foo.getDeclaredAnnotations().length);
+ }
+
+ public void testGetAjTypes() {
+ AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+ AjType[] fooTypes = foo.getAjTypes();
+ assertEquals(1,fooTypes.length);
+ assertEquals("org.aspectj.internal.lang.reflect.Foo$Z",fooTypes[0].getName());
+ }
+
+ public void testGetDeclaredAjTypes() {
+ AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+ AjType[] fooTypes = foo.getDeclaredAjTypes();
+ assertEquals(2,fooTypes.length);
+ // Alex -> Adrian: looks like you can not make assumption on the ordering
+ String s = " " + fooTypes[0].getName() + " " + fooTypes[1].getName();
+ assertTrue(s.indexOf(" org.aspectj.internal.lang.reflect.Foo$Z") >= 0);
+ assertTrue(s.indexOf(" org.aspectj.internal.lang.reflect.Foo$XX") >= 0);
+ }
+
+ public void testGetConstructor() throws Exception {
+ Constructor c1 = String.class.getConstructor(String.class);
+ Constructor c2 = stringType.getConstructor(stringType);
+ assertEquals(c1,c2);
+ }
+
+ public void testGetConstructors() {
+ Constructor[] c1 = String.class.getConstructors();
+ Constructor[] c2 = stringType.getConstructors();
+ assertEquals(c1.length,c2.length);
+ for (int i = 0; i < c1.length; i++)
+ assertEquals(c1[i],c2[i]);
+ }
+
+ public void testGetDeclaredConstructor() throws Exception {
+ Constructor c1 = String.class.getDeclaredConstructor(String.class);
+ Constructor c2 = stringType.getDeclaredConstructor(stringType);
+ assertEquals(c1,c2);
+ }
+
+ public void testGetDeclaredConstructors() {
+ Constructor[] c1 = String.class.getDeclaredConstructors();
+ Constructor[] c2 = stringType.getDeclaredConstructors();
+ assertEquals(c1.length,c2.length);
+ for (int i = 0; i < c1.length; i++)
+ assertEquals(c1[i],c2[i]);
+ }
+
+ public void testGetDeclaredField() throws Exception {
+ Field f1 = String.class.getDeclaredField("value");
+ Field f2 = stringType.getDeclaredField("value");
+ assertEquals(f1,f2);
+ }
+
+ public void testGetDeclaredFields() {
+ Field[] f1 = String.class.getDeclaredFields();
+ Field[] f2 = stringType.getDeclaredFields();
+ assertEquals(f1.length,f2.length);
+ for (int i = 0; i < f1.length; i++)
+ assertEquals(f1[i],f2[i]);
+ }
+
+ public void testGetField() throws Exception {
+ AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+ assertEquals("g",goo.getField("g").getName());
+ }
+
+ public void testGetFields() {
+ AjType<Goo> goo = AjTypeSystem.getAjType(Goo.class);
+ Field[] fields = goo.getFields();
+ assertEquals(1,fields.length);
+ assertEquals("g",fields[0].getName());
+
+ }
+
+ public void testGetDeclaredMethod() throws Exception {
+ Method m1 = String.class.getDeclaredMethod("toUpperCase");
+ Method m2 = stringType.getDeclaredMethod("toUpperCase");
+ assertEquals(m1,m2);
+ }
+
+ public void testGetMethod() throws Exception {
+ Method m1 = String.class.getMethod("toUpperCase");
+ Method m2 = stringType.getMethod("toUpperCase");
+ assertEquals(m1,m2);
+ }
+
+ public void testGetDeclaredMethods() {
+ Method[] m1 = String.class.getDeclaredMethods();
+ Method[] m2 = stringType.getDeclaredMethods();
+ assertEquals(m1.length,m2.length);
+ for (int i = 0; i < m1.length; i++)
+ assertEquals(m1[i],m2[i]);
+ }
+
+ public void testGetMethods() {
+ Method[] m1 = String.class.getMethods();
+ Method[] m2 = stringType.getMethods();
+ assertEquals(m1.length,m2.length);
+ for (int i = 0; i < m1.length; i++)
+ assertEquals(m1[i],m2[i]);
+ }
+
+ public void testGetEnumConstants() {
+ AjType e = AjTypeSystem.getAjType(E.class);
+ Object[] consts = e.getEnumConstants();
+ assertEquals(3,consts.length);
+ }
+
+ public void testGetTypeParameters() {
+ AjType<Foo> foo = AjTypeSystem.getAjType(Foo.class);
+ TypeVariable<Class<Foo>>[] tvs = foo.getTypeParameters();
+ assertEquals(1,tvs.length);
+ assertEquals("T",tvs[0].getName());
+ }
+
+ public void testIsEnum() {
+ assertFalse(stringType.isEnum());
+ }
+
+ public void testIsInstance() {
+ assertTrue(stringType.isInstance("I am"));
+ }
+
+ public void testIsInterface() {
+ assertFalse(stringType.isInterface());
+ assertTrue(AjTypeSystem.getAjType(Serializable.class).isInterface());
+ }
+
+ public void testIsLocalClass() {
+ assertFalse(stringType.isLocalClass());
+ }
+
+ public void testIsArray() {
+ assertFalse(stringType.isArray());
+ assertTrue(AjTypeSystem.getAjType(Integer[].class).isArray());
+ }
+
+ public void testIsPrimitive() {
+ assertFalse(stringType.isPrimitive());
+ assertTrue(AjTypeSystem.getAjType(boolean.class).isPrimitive());
+ }
+
+ public void testIsAspect() {
+ assertFalse(stringType.isAspect());
+ }
+
+ public void testIsMemberAspect() {
+ assertFalse(stringType.isMemberAspect());
+ }
+
+ public void testIsPrivileged() {
+ assertFalse(stringType.isPrivileged());
+ }
+
+ public void testEquals() {
+ AjType stringTypeTwo = AjTypeSystem.getAjType(String.class);
+ assertTrue(stringType.equals(stringTypeTwo));
+ }
+
+ public void testHashCode() {
+ AjType stringTypeTwo = AjTypeSystem.getAjType(String.class);
+ assertEquals(stringType.hashCode(),stringTypeTwo.hashCode());
+ }
+
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface SomeAnn {}
+
+@SomeAnn
+class Foo<T> {
+
+ public Foo() {
+ class Y { int y; }
+ AjType t = AjTypeSystem.getAjType(Y.class);
+ Constructor c = t.getEnclosingConstructor();
+ if (!c.getName().equals("org.aspectj.internal.lang.reflect.Foo")) throw new RuntimeException("should have been Foo");
+ }
+ public void foo() {
+ class X { int x; }
+ AjType t = AjTypeSystem.getAjType(X.class);
+ Method m = t.getEnclosingMethod();
+ if (!m.getName().equals("foo")) throw new RuntimeException("should have been foo");
+ }
+ public class Z { int z; }
+ class XX { int xx; }
+}
+
+class Goo extends Foo {
+ @interface IX {}
+
+ public Goo() {
+ super();
+ }
+
+ public int g;
+ int g2;
+
+}
+
+enum E { A,B,C; }
diff --git a/runtime/src/test/java/org/aspectj/internal/lang/reflect/AjTypeWithAspectsTest.java b/runtime/src/test/java/org/aspectj/internal/lang/reflect/AjTypeWithAspectsTest.java
new file mode 100644
index 000000000..af72d26f5
--- /dev/null
+++ b/runtime/src/test/java/org/aspectj/internal/lang/reflect/AjTypeWithAspectsTest.java
@@ -0,0 +1,449 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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://eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Adrian Colyer initial implementation
+ * ******************************************************************/
+package org.aspectj.internal.lang.reflect;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import junit.framework.TestCase;
+
+import org.aspectj.internal.lang.annotation.ajcDeclareEoW;
+import org.aspectj.internal.lang.annotation.ajcPrivileged;
+import org.aspectj.lang.annotation.AdviceName;
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.DeclareError;
+import org.aspectj.lang.annotation.DeclareWarning;
+import org.aspectj.lang.reflect.Advice;
+import org.aspectj.lang.reflect.AdviceKind;
+import org.aspectj.lang.reflect.AjType;
+import org.aspectj.lang.reflect.AjTypeSystem;
+import org.aspectj.lang.reflect.DeclareErrorOrWarning;
+import org.aspectj.lang.reflect.NoSuchAdviceException;
+import org.aspectj.lang.reflect.NoSuchPointcutException;
+import org.aspectj.lang.reflect.PerClause;
+import org.aspectj.lang.reflect.PerClauseKind;
+import org.aspectj.lang.reflect.Pointcut;
+import org.aspectj.lang.reflect.PointcutBasedPerClause;
+import org.aspectj.lang.reflect.TypePatternBasedPerClause;
+
+public class AjTypeWithAspectsTest extends TestCase {
+
+ private AjType<SimpleAspect> sa;
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ sa = AjTypeSystem.getAjType(SimpleAspect.class);
+ }
+
+ public void testGetPerClause() {
+ AjType<PerThisAspect> perThisA = AjTypeSystem.getAjType(PerThisAspect.class);
+ AjType<PerTargetAspect> perTargetA = AjTypeSystem.getAjType(PerTargetAspect.class);
+ AjType<PerCflowAspect> perCflowA = AjTypeSystem.getAjType(PerCflowAspect.class);
+ AjType<PerCflowbelowAspect> perCflowbelowA = AjTypeSystem.getAjType(PerCflowbelowAspect.class);
+ AjType<PerTypeWithin> perTypeWithinA = AjTypeSystem.getAjType(PerTypeWithin.class);
+
+ PerClause pc = perThisA.getPerClause();
+ assertEquals(PerClauseKind.PERTHIS,pc.getKind());
+ assertEquals("pc()",((PointcutBasedPerClause)pc).getPointcutExpression().asString());
+ assertEquals("perthis(pc())",pc.toString());
+
+ pc= perTargetA.getPerClause();
+ assertEquals(PerClauseKind.PERTARGET,pc.getKind());
+ assertEquals("pc()",((PointcutBasedPerClause)pc).getPointcutExpression().asString());
+ assertEquals("pertarget(pc())",pc.toString());
+
+ pc= perCflowA.getPerClause();
+ assertEquals(PerClauseKind.PERCFLOW,pc.getKind());
+ assertEquals("pc()",((PointcutBasedPerClause)pc).getPointcutExpression().asString());
+ assertEquals("percflow(pc())",pc.toString());
+
+ pc= perCflowbelowA.getPerClause();
+ assertEquals(PerClauseKind.PERCFLOWBELOW,pc.getKind());
+ assertEquals("pc()",((PointcutBasedPerClause)pc).getPointcutExpression().asString());
+ assertEquals("percflowbelow(pc())",pc.toString());
+
+ pc= perTypeWithinA.getPerClause();
+ assertEquals(PerClauseKind.PERTYPEWITHIN,pc.getKind());
+ assertEquals("org.aspectj..*",((TypePatternBasedPerClause)pc).getTypePattern().asString());
+ assertEquals("pertypewithin(org.aspectj..*)",pc.toString());
+
+ }
+
+ public void testGetDeclaredField() throws Exception{
+ Field f = sa.getDeclaredField("s");
+ try {
+ Field f2 = sa.getDeclaredField("ajc$xyz$s");
+ fail("Expecting NoSuchFieldException");
+ } catch (NoSuchFieldException nsf) {}
+ }
+
+ public void testGetField() throws Exception {
+ Field f = sa.getField("s");
+ try {
+ Field f2 = sa.getField("ajc$xyz$s");
+ fail("Expecting NoSuchFieldException");
+ } catch (NoSuchFieldException nsf) {}
+ }
+
+ public void testGetDeclaredFields() {
+ Field[] fields = sa.getDeclaredFields();
+ assertEquals(1,fields.length);
+ assertEquals("s",fields[0].getName());
+ }
+
+ public void testGetFields() {
+ Field[] fields = sa.getFields();
+ assertEquals(1,fields.length);
+ assertEquals("s",fields[0].getName());
+ }
+
+ public void testGetDeclaredMethod() throws Exception {
+ Method m = sa.getDeclaredMethod("aMethod");
+ try {
+ Method m2 = sa.getDeclaredMethod("logEntry");
+ fail("Expecting NoSuchMethodException");
+ } catch(NoSuchMethodException ex) {}
+ try {
+ Method m3 = sa.getDeclaredMethod("ajc$before$123");
+ fail("Expecting NoSuchMethodException");
+ } catch(NoSuchMethodException ex) {}
+ }
+
+ public void testGetMethod() throws Exception {
+ Method m = sa.getMethod("aMethod");
+ try {
+ Method m2 = sa.getMethod("logEntry");
+ fail("Expecting NoSuchMethodException");
+ } catch(NoSuchMethodException ex) {}
+ try {
+ Method m3 = sa.getMethod("ajc$before$123");
+ fail("Expecting NoSuchMethodException");
+ } catch(NoSuchMethodException ex) {}
+ }
+
+ public void testGetDeclaredMethods() {
+ Method[] ms = sa.getDeclaredMethods();
+ assertEquals(1,ms.length);
+ assertEquals("aMethod",ms[0].getName());
+ }
+
+ public void testGetMethods() {
+ Method[] ms = sa.getMethods();
+ assertEquals(10,ms.length);
+ //AV was corrupted, cannot rely on ordering
+ String match = "";
+ for (int i = 0; i < ms.length; i++) {
+ match = match + "--" + ms[i].getName();
+ }
+ assertTrue(match.indexOf("aMethod") >=0);
+ }
+
+ public void testGetDeclaredPointcut() throws Exception {
+ Pointcut p1 = sa.getDeclaredPointcut("simpleAspectMethodExecution");
+ assertEquals("simpleAspectMethodExecution",p1.getName());
+ assertEquals("execution(* SimpleAspect.*(..))",p1.getPointcutExpression().asString());
+ assertEquals("simpleAspectMethodExecution() : execution(* SimpleAspect.*(..))",p1.toString());
+ assertEquals(sa,p1.getDeclaringType());
+ assertEquals(0,p1.getParameterTypes().length);
+ assertTrue(Modifier.isPublic(p1.getModifiers()));
+ Pointcut p2 = sa.getDeclaredPointcut("simpleAspectCall");
+ assertEquals("simpleAspectCall",p2.getName());
+ assertEquals("call(* SimpleAspect.*(..))",p2.getPointcutExpression().asString());
+ assertEquals(sa,p2.getDeclaringType());
+ assertEquals(1,p2.getParameterTypes().length);
+ assertTrue(Modifier.isPrivate(p2.getModifiers()));
+ try {
+ Pointcut p3 = sa.getDeclaredPointcut("sausages");
+ fail("Expecting NoSuchPointcutExcetpion");
+ } catch (NoSuchPointcutException ex) {
+ assertEquals("sausages",ex.getName());
+ }
+ }
+
+ public void testGetPointcut() throws Exception {
+ Pointcut p1 = sa.getPointcut("simpleAspectMethodExecution");
+ assertEquals("simpleAspectMethodExecution",p1.getName());
+ assertEquals("execution(* SimpleAspect.*(..))",p1.getPointcutExpression().asString());
+ assertEquals(sa,p1.getDeclaringType());
+ assertEquals(0,p1.getParameterTypes().length);
+ assertTrue(Modifier.isPublic(p1.getModifiers()));
+ Pointcut p2 = sa.getDeclaredPointcut("simpleAspectCall");
+ assertEquals("simpleAspectCall",p2.getName());
+ assertEquals("call(* SimpleAspect.*(..))",p2.getPointcutExpression().asString());
+ assertEquals(sa,p2.getDeclaringType());
+ assertEquals(1,p2.getParameterTypes().length);
+ assertTrue(Modifier.isPrivate(p2.getModifiers()));
+ try {
+ Pointcut p3 = sa.getPointcut("sausages");
+ fail("Expecting NoSuchPointcutExcetpion");
+ } catch (NoSuchPointcutException ex) {
+ assertEquals("sausages",ex.getName());
+ }
+ }
+
+ public void testGetDeclaredPointcuts() {
+ Pointcut[] pcs = sa.getDeclaredPointcuts();
+ assertEquals(2,pcs.length);
+ // AV was corrupted, cannot rely on ordering
+ String match = "simpleAspectMethodExecution--simpleAspectCall";
+ assertTrue(match.indexOf(pcs[0].getName()) >= 0);
+ assertTrue(match.indexOf(pcs[1].getName()) >= 0);
+ }
+
+ public void testGetPointcuts() {
+ Pointcut[] pcs = sa.getPointcuts();
+ assertEquals(1,pcs.length);
+ assertEquals("simpleAspectMethodExecution",pcs[0].getName());
+ }
+
+ public void testGetDeclaredAdvice() {
+ Advice[] advice = sa.getDeclaredAdvice();
+ assertEquals(10,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.BEFORE);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.AFTER);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.AFTER_RETURNING);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.AFTER_THROWING);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.AROUND);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.BEFORE,AdviceKind.AFTER);
+ assertEquals(4,advice.length);
+
+ advice = sa.getDeclaredAdvice(AdviceKind.BEFORE);
+ // AV: corrupted test: cannot rely on ordering since a Set is used behind
+ Advice aone, atwo;
+ if (advice[0].getName()!=null && advice[0].getName().length()>0) {
+ aone = advice[0];
+ atwo = advice[1];
+ } else {
+ aone = advice[1];
+ atwo = advice[0];
+ }
+ assertEquals("execution(* SimpleAspect.*(..))",aone.getPointcutExpression().toString());
+ assertEquals("@AdviceName(\"logEntry\") before() : execution(* SimpleAspect.*(..))",aone.toString());
+ assertEquals("logEntry",aone.getName());
+ assertEquals(AdviceKind.BEFORE,aone.getKind());
+ assertEquals("execution(* SimpleAspect.*(..))",atwo.getPointcutExpression().toString());
+ assertEquals("",atwo.getName());
+ assertEquals("before() : execution(* SimpleAspect.*(..))",atwo.toString());
+ }
+
+ public void testGetAdvice() {
+ Advice[] advice = sa.getDeclaredAdvice();
+ assertEquals(10,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.BEFORE);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.AFTER);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.AFTER_RETURNING);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.AFTER_THROWING);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.AROUND);
+ assertEquals(2,advice.length);
+ advice = sa.getDeclaredAdvice(AdviceKind.BEFORE,AdviceKind.AFTER);
+ assertEquals(4,advice.length);
+ }
+
+ public void testGetNamedAdvice() throws Exception {
+ Advice a = sa.getAdvice("logItAll");
+ assertEquals("logItAll",a.getName());
+ assertEquals(AdviceKind.AROUND,a.getKind());
+ a = sa.getAdvice("whatGoesAround");
+ assertEquals("whatGoesAround",a.getName());
+ assertEquals(AdviceKind.AROUND,a.getKind());
+ try {
+ a = sa.getAdvice("ajc$after$123");
+ fail("Expecting NoSuchAdviceException");
+ } catch (NoSuchAdviceException ex) {
+ assertEquals("ajc$after$123",ex.getName());
+ }
+ try {
+ a = sa.getAdvice("");
+ fail("Expecting IllegalArgumentException");
+ } catch (IllegalArgumentException ex) {
+ ;
+ }
+ }
+
+ public void testGetNamedDeclaredAdvice() throws Exception {
+ Advice a = sa.getDeclaredAdvice("logItAll");
+ assertEquals("logItAll",a.getName());
+ assertEquals(AdviceKind.AROUND,a.getKind());
+ a = sa.getDeclaredAdvice("whatGoesAround");
+ assertEquals("whatGoesAround",a.getName());
+ assertEquals(AdviceKind.AROUND,a.getKind());
+ try {
+ a = sa.getDeclaredAdvice("ajc$after$123");
+ fail("Expecting NoSuchAdviceException");
+ } catch (NoSuchAdviceException ex) {
+ assertEquals("ajc$after$123",ex.getName());
+ }
+ try {
+ a = sa.getDeclaredAdvice("");
+ fail("Expecting IllegalArgumentException");
+ } catch (IllegalArgumentException ex) {
+ ;
+ }
+ }
+
+ public void testIsPrivileged() {
+ assertFalse(sa.isPrivileged());
+ assertTrue(AjTypeSystem.getAjType(SimplePrivilegedAspect.class).isPrivileged());
+ }
+
+ public void testIsAspect() {
+ assertTrue(sa.isAspect());
+ }
+
+ public void testIsMemberAspect() {
+ assertFalse(AjTypeSystem.getAjType(SimplePrivilegedAspect.class).isMemberAspect());
+ assertTrue(AjTypeSystem.getAjType(SimplePrivilegedAspect.MemberAspect.class).isMemberAspect());
+
+ }
+
+ public void testGetDeclareEoWarnings() {
+ DeclareErrorOrWarning[] deows = sa.getDeclareErrorOrWarnings();
+ assertEquals(4,deows.length);
+ boolean foundCodeWarning = false;
+ boolean foundCodeError = false;
+ boolean foundAnnWarning = false;
+ boolean foundAnnError = false;
+ for (DeclareErrorOrWarning deow : deows) {
+ if (deow.isError()) {
+ if (deow.getMessage().equals("dont call this method code")) {
+ foundCodeError = true;
+ assertEquals("declare error : call(* DontDoIt.*(..)) : \"dont call this method code\"",deow.toString());
+ }
+ if (deow.getMessage().equals("dont call this method ann")) foundAnnError = true;
+ assertEquals("call(* DontDoIt.*(..))",deow.getPointcutExpression().toString());
+ } else {
+ if (deow.getMessage().equals("dont call this method code")) foundCodeWarning = true;
+ if (deow.getMessage().equals("dont call this method ann")) foundAnnWarning = true;
+ assertEquals("call(* DontDoIt.*(..))",deow.getPointcutExpression().toString());
+ }
+ }
+ assertTrue(foundCodeWarning && foundAnnWarning && foundCodeError && foundAnnError);
+ }
+
+}
+
+
+@Aspect
+class SimpleAspect {
+
+ // regular field
+ public String s;
+
+ // synthetic field
+ public String ajc$xyz$s;
+
+ // regular method
+ public void aMethod() {}
+
+ // advice method, annotation style
+ @Before("execution(* SimpleAspect.*(..))")
+ public void logEntry() {}
+
+ // advice method, code style
+ @Before("execution(* SimpleAspect.*(..))")
+ public void ajc$before$123() {}
+
+ // advice method, annotation style
+ @After("execution(* SimpleAspect.*(..))")
+ public void logFinally() {}
+
+ // advice method, code style
+ @After("execution(* SimpleAspect.*(..))")
+ public void ajc$after$123() {}
+
+ // advice method, annotation style
+ @AfterReturning("execution(* SimpleAspect.*(..))")
+ public void logExit() {}
+
+ // advice method, code style
+ @AfterReturning("execution(* SimpleAspect.*(..))")
+ public void ajc$afterReturning$123() {}
+
+ // advice method, annotation style
+ @AfterThrowing("execution(* SimpleAspect.*(..))")
+ public void logException() {}
+
+ // advice method, code style
+ @AfterThrowing("execution(* SimpleAspect.*(..))")
+ public void ajc$afterThrowing$123() {}
+
+ // advice method, annotation style
+ @Around("execution(* SimpleAspect.*(..))")
+ public void logItAll() {}
+
+ // advice method, code style
+ @Around("execution(* SimpleAspect.*(..))")
+ @AdviceName("whatGoesAround")
+ public void ajc$around$123() {}
+
+ // pointcut, annotation style
+ @org.aspectj.lang.annotation.Pointcut("execution(* SimpleAspect.*(..))")
+ public void simpleAspectMethodExecution() {};
+
+ // pointcut, code style
+ @org.aspectj.lang.annotation.Pointcut("call(* SimpleAspect.*(..))")
+ private void ajc$pointcut$$simpleAspectCall$123(SimpleAspect target) {};
+
+ // decw, ann style
+ @DeclareWarning("call(* DontDoIt.*(..))")
+ public static final String dontDoIt = "dont call this method ann";
+
+ // decw, code style
+ @ajcDeclareEoW(pointcut="call(* DontDoIt.*(..))",message="dont call this method code",isError=false)
+ private void ajc$declare_eow$123() {}
+
+ // dec., ann style
+ @DeclareError("call(* DontDoIt.*(..))")
+ public static final String dontDoItISaid = "dont call this method ann";
+
+ // decw, code style
+ @ajcDeclareEoW(pointcut="call(* DontDoIt.*(..))",message="dont call this method code",isError=true)
+ private void ajc$declare_eow$124() {}
+}
+
+@Aspect
+@ajcPrivileged
+class SimplePrivilegedAspect {
+
+ @Aspect
+ static class MemberAspect {}
+
+}
+
+@Aspect("perthis(pc())")
+class PerThisAspect {}
+
+@Aspect("pertarget(pc())")
+class PerTargetAspect {}
+
+@Aspect("percflow(pc())")
+class PerCflowAspect {}
+
+@Aspect("percflowbelow(pc())")
+class PerCflowbelowAspect {}
+
+@Aspect("pertypewithin(org.aspectj..*)")
+class PerTypeWithin {}
diff --git a/runtime/src/test/java/org/aspectj/internal/lang/reflect/InterTypeTest.java b/runtime/src/test/java/org/aspectj/internal/lang/reflect/InterTypeTest.java
new file mode 100644
index 000000000..128993d67
--- /dev/null
+++ b/runtime/src/test/java/org/aspectj/internal/lang/reflect/InterTypeTest.java
@@ -0,0 +1,88 @@
+/* *******************************************************************
+ * Copyright (c) 2005 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://eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Adrian Colyer Initial implementation
+ * ******************************************************************/
+package org.aspectj.internal.lang.reflect;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+import org.aspectj.lang.reflect.AjType;
+import org.aspectj.lang.reflect.AjTypeSystem;
+import org.aspectj.lang.reflect.InterTypeConstructorDeclaration;
+import org.aspectj.lang.reflect.InterTypeDeclaration;
+import org.aspectj.lang.reflect.InterTypeFieldDeclaration;
+import org.aspectj.lang.reflect.InterTypeMethodDeclaration;
+
+import junit.framework.TestCase;
+
+/**
+ * @author colyer
+ *
+ */
+public class InterTypeTest extends TestCase {
+
+ public void testITDImpl() throws ClassNotFoundException {
+ AjType<InterTypeTest> thisClass = AjTypeSystem.getAjType(InterTypeTest.class);
+ AjType<Runnable> runnable = AjTypeSystem.getAjType(java.lang.Runnable.class);
+ InterTypeDeclaration itd = new InterTypeDeclarationImpl(thisClass,"java.lang.Runnable",5);
+ assertEquals(thisClass,itd.getDeclaringType());
+ assertEquals(runnable,itd.getTargetType());
+ assertEquals(5, itd.getModifiers());
+ }
+
+ public void testITDField() throws ClassNotFoundException {
+ AjType<InterTypeTest> thisClass = AjTypeSystem.getAjType(InterTypeTest.class);
+ AjType<Runnable> runnable = AjTypeSystem.getAjType(java.lang.Runnable.class);
+ InterTypeDeclaration itd = new InterTypeDeclarationImpl(thisClass,"java.lang.Runnable",5);
+ AjType<String> stringType = AjTypeSystem.getAjType(java.lang.String.class);
+ Type t = Type.class;
+ InterTypeFieldDeclaration itdf = new InterTypeFieldDeclarationImpl(thisClass,"java.lang.Runnable",5,"f",stringType,t);
+ assertEquals("f",itdf.getName());
+ assertEquals(stringType,itdf.getType());
+ assertEquals(t,itdf.getGenericType());
+ }
+
+ public void testITDCons() throws ClassNotFoundException, NoSuchMethodException {
+ AjType<InterTypeTest> thisClass = AjTypeSystem.getAjType(InterTypeTest.class);
+ AjType<Runnable> runnable = AjTypeSystem.getAjType(java.lang.Runnable.class);
+ Method base = InterTypeTest.class.getDeclaredMethod("interCons",InterTypeTest.class,String.class,int.class);
+ InterTypeConstructorDeclaration itdc =
+ new InterTypeConstructorDeclarationImpl(thisClass,"java.lang.Runnable",5,base);
+ assertEquals(2,itdc.getParameterTypes().length);
+ assertEquals(String.class,itdc.getParameterTypes()[0].getJavaClass());
+ assertEquals(int.class,itdc.getParameterTypes()[1].getJavaClass());
+ assertEquals(2,itdc.getGenericParameterTypes().length);
+ assertEquals(base.getGenericParameterTypes()[1],((AjType<?>)itdc.getGenericParameterTypes()[0]).getJavaClass());
+ assertEquals(base.getGenericParameterTypes()[2],((AjType<?>)itdc.getGenericParameterTypes()[1]).getJavaClass());
+ assertEquals(0,itdc.getExceptionTypes().length);
+ }
+
+ public void testITDMethod() throws NoSuchMethodException {
+ AjType<InterTypeTest> thisClass = AjTypeSystem.getAjType(InterTypeTest.class);
+ AjType<Runnable> runnable = AjTypeSystem.getAjType(java.lang.Runnable.class);
+ Method base = InterTypeTest.class.getDeclaredMethod("interMethod",InterTypeTest.class,String.class,int.class);
+ InterTypeMethodDeclaration itdm = new InterTypeMethodDeclarationImpl(thisClass,"java.lang.Runnable",5,"foo",base);
+ assertEquals("foo",itdm.getName());
+ assertEquals(int.class,itdm.getReturnType().getJavaClass());
+ assertEquals(int.class,((AjType<?>)itdm.getGenericReturnType()).getJavaClass());
+ assertEquals(2,itdm.getParameterTypes().length);
+ assertEquals(String.class,itdm.getParameterTypes()[0].getJavaClass());
+ assertEquals(int.class,itdm.getParameterTypes()[1].getJavaClass());
+ assertEquals(2,itdm.getGenericParameterTypes().length);
+ assertEquals(base.getGenericParameterTypes()[1],((AjType<?>)itdm.getGenericParameterTypes()[0]).getJavaClass());
+ assertEquals(base.getGenericParameterTypes()[2],((AjType<?>)itdm.getGenericParameterTypes()[1]).getJavaClass());
+ assertEquals(0,itdm.getExceptionTypes().length);
+ }
+
+ public static void interCons(InterTypeTest itt, String s, int i) { }
+
+ public static int interMethod(InterTypeTest itt, String s, int i) { return 5; }
+}