public class AllTests {
public static Test suite() {
- TestSuite suite = new TestSuite("Tests for BCEL");
+ TestSuite suite = new TestSuite("Tests for BCEL Java5 support");
//$JUnit-BEGIN$
- suite.addTestSuite(Fundamentals.class);
suite.addTestSuite(RuntimeVisibleParameterAnnotationAttributeTest.class);
suite.addTestSuite(AnnotationDefaultAttributeTest.class);
suite.addTestSuite(EnclosingMethodAttributeTest.class);
import org.aspectj.apache.bcel.classfile.AnnotationDefault;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Method;
-import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValueGen;
+import org.aspectj.apache.bcel.classfile.annotation.ElementValue;
+import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValue;
public class AnnotationDefaultAttributeTest extends BcelTestCase {
Method m = getMethod(clazz,"fruit");
AnnotationDefault a = (AnnotationDefault) findAttribute("AnnotationDefault",m.getAttributes());
- SimpleElementValueGen val = (SimpleElementValueGen) a.getElementValue();
+ SimpleElementValue val = (SimpleElementValue) a.getElementValue();
assertTrue("Should be STRING but is "+val.getElementValueType(),
- val.getElementValueType()==ElementValueGen.STRING);
+ val.getElementValueType()==ElementValue.STRING);
assertTrue("Should have default of bananas but default is "+val.getValueString(),
val.getValueString().equals("bananas"));
}
import org.aspectj.apache.bcel.Constants;
import org.aspectj.apache.bcel.classfile.Utility;
import org.aspectj.apache.bcel.classfile.Attribute;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeVisibleAnnotations;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeInvisibleAnnotations;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeAnnotations;
-import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValueGen;
import org.aspectj.apache.bcel.generic.ClassGen;
-import org.aspectj.apache.bcel.classfile.ConstantPool;
+import org.aspectj.apache.bcel.generic.ConstantPoolGen;
import org.aspectj.apache.bcel.generic.ObjectType;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.SimpleElementValueGen;
public class AnnotationGenTest extends BcelTestCase {
// Create the containing class
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
// Create the simple primitive value '4' of type 'int'
SimpleElementValueGen evg =
// Create the containing class
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
// Create the simple primitive value '4' of type 'int'
SimpleElementValueGen evg =
////
// Helper methods
- private void checkSerialize(AnnotationGen a,ConstantPool cpg) {
+ private void checkSerialize(AnnotationGen a,ConstantPoolGen cpg) {
try {
String beforeName = a.getTypeName();
List beforeValues = a.getValues();
import org.aspectj.apache.bcel.classfile.Attribute;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Method;
-import org.aspectj.apache.bcel.classfile.ConstantPool;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValueGen;
+import org.aspectj.apache.bcel.classfile.annotation.Annotation;
+import org.aspectj.apache.bcel.generic.ConstantPoolGen;
import org.aspectj.apache.bcel.generic.ObjectType;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.SimpleElementValueGen;
import org.aspectj.apache.bcel.util.ClassPath;
import org.aspectj.apache.bcel.util.SyntheticRepository;
return (Attribute)chosenAttrsList.get(0);
}
+ protected String dumpAnnotations(Annotation[] as) {
+ StringBuffer result = new StringBuffer();
+ result.append("[");
+ for (int i = 0; i < as.length; i++) {
+ Annotation annotation = as[i];
+ result.append(annotation.toShortString());
+ if (i+1<as.length) result.append(",");
+ }
+ result.append("]");
+ return result.toString();
+ }
protected String dumpAnnotations(AnnotationGen[] as) {
StringBuffer result = new StringBuffer();
return result.toString();
}
- public AnnotationGen createFruitAnnotation(ConstantPool cp, String aFruit, boolean visibility) {
+ public AnnotationGen createFruitAnnotation(ConstantPoolGen cp, String aFruit, boolean visibility) {
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.STRING,cp,aFruit);
ElementNameValuePairGen nvGen = new ElementNameValuePairGen("fruit",evg,cp);
ObjectType t = new ObjectType("SimpleStringAnnotation");
import org.aspectj.apache.bcel.Constants;
import org.aspectj.apache.bcel.generic.ClassGen;
-import org.aspectj.apache.bcel.classfile.ConstantPool;
-import org.aspectj.apache.bcel.classfile.annotation.ClassElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.EnumElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValueGen;
+import org.aspectj.apache.bcel.generic.ConstantPoolGen;
import org.aspectj.apache.bcel.generic.ObjectType;
+import org.aspectj.apache.bcel.generic.annotation.ClassElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.EnumElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.SimpleElementValueGen;
public class ElementValueGenTest extends BcelTestCase {
public void testCreateIntegerElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.PRIMITIVE_INT,cp,555);
// Creation of an element like that should leave a new entry in the cpool
public void testCreateFloatElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.PRIMITIVE_FLOAT,cp,111.222f);
// Creation of an element like that should leave a new entry in the cpool
public void testCreateDoubleElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.PRIMITIVE_DOUBLE,cp,333.44);
// Creation of an element like that should leave a new entry in the cpool
public void testCreateLongElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.PRIMITIVE_LONG,cp,3334455L);
// Creation of an element like that should leave a new entry in the cpool
public void testCreateCharElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.PRIMITIVE_CHAR,cp,(char)'t');
// Creation of an element like that should leave a new entry in the cpool
public void testCreateByteElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.PRIMITIVE_CHAR,cp,(byte)'z');
// Creation of an element like that should leave a new entry in the cpool
public void testCreateBooleanElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.PRIMITIVE_BOOLEAN,cp,true);
// Creation of an element like that should leave a new entry in the cpool
public void testCreateShortElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.PRIMITIVE_SHORT,cp,(short)42);
// Creation of an element like that should leave a new entry in the cpool
// Create HelloWorld
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.STRING,cp,"hello");
// Creation of an element like that should leave a new entry in the cpool
public void testCreateEnumElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
ObjectType enumType = new ObjectType("SimpleEnum"); // Supports rainbow :)
public void testCreateClassElementValue() {
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
ObjectType classType = new ObjectType("java.lang.Integer");
////
// Helper methods
- private void checkSerialize(ElementValueGen evgBefore,ConstantPool cpg) {
+ private void checkSerialize(ElementValueGen evgBefore,ConstantPoolGen cpg) {
try {
String beforeValue = evgBefore.stringifyValue();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
import org.aspectj.apache.bcel.classfile.Field;
import org.aspectj.apache.bcel.classfile.JavaClass;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.classfile.annotation.Annotation;
+import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePair;
import org.aspectj.apache.bcel.generic.ClassGen;
import org.aspectj.apache.bcel.generic.FieldGen;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;
import org.aspectj.apache.bcel.util.SyntheticRepository;
for (int i = 0; i < fields.length; i++) {
Field f = fields[i];
- AnnotationGen[] fieldAnnotations = f.getAnnotations();
+ Annotation[] fieldAnnotations = f.getAnnotations();
if (f.getName().equals(fieldname)) {
checkAnnotation(fieldAnnotations[0],annotationName,annotationElementName,annotationElementValue);
}
}
- private void checkAnnotation(AnnotationGen a,String name,String elementname,String elementvalue) {
+ private void checkAnnotation(Annotation a,String name,String elementname,String elementvalue) {
assertTrue("Expected annotation to have name "+name+" but it had name "+a.getTypeName(),
a.getTypeName().equals(name));
assertTrue("Expected annotation to have one element but it had "+a.getValues().size(),a.getValues().size()==1);
- ElementNameValuePairGen envp = (ElementNameValuePairGen)a.getValues().get(0);
+ ElementNameValuePair envp = (ElementNameValuePair)a.getValues().get(0);
assertTrue("Expected element name "+elementname+" but was "+envp.getNameString(),
elementname.equals(envp.getNameString()));
assertTrue("Expected element value "+elementvalue+" but was "+envp.getValue().stringifyValue(),
// helper methods
- public void checkValue(AnnotationGen a,String name,String tostring) {
+ public void checkValue(Annotation a,String name,String tostring) {
for (Iterator i = a.getValues().iterator(); i.hasNext();) {
- ElementNameValuePairGen element = (ElementNameValuePairGen) i.next();
+ ElementNameValuePair element = (ElementNameValuePair) i.next();
if (element.getNameString().equals(name)) {
if (!element.getValue().stringifyValue().equals(tostring)) {
fail("Expected element "+name+" to have value "+tostring+" but it had value "+element.getValue().stringifyValue());
import org.aspectj.apache.bcel.Constants;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Method;
+import org.aspectj.apache.bcel.classfile.annotation.Annotation;
+import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePair;
+import org.aspectj.apache.bcel.classfile.annotation.ElementValue;
+import org.aspectj.apache.bcel.generic.ALOAD;
+import org.aspectj.apache.bcel.generic.ASTORE;
import org.aspectj.apache.bcel.generic.ArrayType;
import org.aspectj.apache.bcel.generic.ClassGen;
-import org.aspectj.apache.bcel.classfile.ConstantPool;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ArrayElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValueGen;
-import org.aspectj.apache.bcel.generic.InstructionBranch;
+import org.aspectj.apache.bcel.generic.ConstantPoolGen;
+import org.aspectj.apache.bcel.generic.GOTO;
import org.aspectj.apache.bcel.generic.InstructionConstants;
import org.aspectj.apache.bcel.generic.InstructionFactory;
import org.aspectj.apache.bcel.generic.InstructionHandle;
import org.aspectj.apache.bcel.generic.LocalVariableGen;
import org.aspectj.apache.bcel.generic.MethodGen;
import org.aspectj.apache.bcel.generic.ObjectType;
+import org.aspectj.apache.bcel.generic.PUSH;
import org.aspectj.apache.bcel.generic.Type;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;
+import org.aspectj.apache.bcel.generic.annotation.ArrayElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.SimpleElementValueGen;
import org.aspectj.apache.bcel.util.SyntheticRepository;
/**
// Create HelloWorld
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
InstructionList il = new InstructionList();
cg.addAnnotation(createSimpleVisibleAnnotation(cp));
JavaClass jc = getClassFrom(".","HelloWorld");
- AnnotationGen[] as = jc.getAnnotations();
+ Annotation[] as = jc.getAnnotations();
assertTrue("Should be two annotations but found "+as.length,as.length==2);
- AnnotationGen one = as[0];
- AnnotationGen two = as[1];
+ Annotation one = as[0];
+ Annotation two = as[1];
assertTrue("Name of annotation 1 should be SimpleAnnotation but it is "+as[0].getTypeName(),
as[0].getTypeName().equals("SimpleAnnotation"));
assertTrue("Name of annotation 2 should be SimpleAnnotation but it is "+as[1].getTypeName(),
as[1].getTypeName().equals("SimpleAnnotation"));
List vals = as[0].getValues();
- ElementNameValuePairGen nvp = (ElementNameValuePairGen) vals.get(0);
+ ElementNameValuePair nvp = (ElementNameValuePair) vals.get(0);
assertTrue("Name of element in SimpleAnnotation should be 'id' but it is "+
nvp.getNameString(),nvp.getNameString().equals("id"));
- ElementValueGen ev = nvp.getValue();
+ ElementValue ev = nvp.getValue();
assertTrue("Type of element value should be int but it is "+ev.getElementValueType(),
- ev.getElementValueType()==ElementValueGen.PRIMITIVE_INT);
+ ev.getElementValueType()==ElementValue.PRIMITIVE_INT);
assertTrue("Value of element should be 4 but it is "+ev.stringifyValue(),
ev.stringifyValue().equals("4"));
assertTrue(createTestdataFile("HelloWorld.class").delete());
public void testGenerateMethodLevelAnnotations1() throws ClassNotFoundException {
// Create HelloWorld
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
InstructionList il = new InstructionList();
buildClassContentsWithAnnotatedMethods(cg, cp, il);
public void testGenerateMethodLevelAnnotations2() throws ClassNotFoundException {
// Create HelloWorld
ClassGen cg = createClassGen("HelloWorld");
- ConstantPool cp = cg.getConstantPool();
+ ConstantPoolGen cp = cg.getConstantPool();
InstructionList il = new InstructionList();
buildClassContentsWithAnnotatedMethods(cg, cp, il);
ElementValueGen value = (ElementValueGen)nvp.getValue();
assertTrue("Value should be ArrayElementValueGen but is "+value,value instanceof ArrayElementValueGen);
ArrayElementValueGen arrayValue = (ArrayElementValueGen)value;
- assertTrue("Array value should be size one but is "+arrayValue.getElementValuesArraySize(),
- arrayValue.getElementValuesArraySize()==1);
- ElementValueGen innerValue = (ElementValueGen)arrayValue.getElementValuesArray()[0];
+ assertTrue("Array value should be size one but is "+arrayValue.getElementValuesSize(),
+ arrayValue.getElementValuesSize()==1);
+ ElementValueGen innerValue = (ElementValueGen)arrayValue.getElementValues().get(0);
assertTrue("Value in the array should be AnnotationElementValueGen but is "+innerValue,
innerValue instanceof AnnotationElementValueGen);
AnnotationElementValueGen innerAnnotationValue = (AnnotationElementValueGen)innerValue;
public void testModifyingClasses1() throws ClassNotFoundException {
JavaClass jc = getClassFrom("testcode.jar","SimpleAnnotatedClass");
ClassGen cgen = new ClassGen(jc);
- ConstantPool cp = cgen.getConstantPool();
+ ConstantPoolGen cp = cgen.getConstantPool();
cgen.addAnnotation(createFruitAnnotation(cp,"Pineapple"));
assertTrue("Should now have two annotations but has "+cgen.getAnnotations().length,
cgen.getAnnotations().length==2);
public void testModifyingClasses2() throws ClassNotFoundException {
JavaClass jc = getClassFrom("testcode.jar","SimpleAnnotatedClass");
ClassGen cgen = new ClassGen(jc);
- ConstantPool cp = cgen.getConstantPool();
+ ConstantPoolGen cp = cgen.getConstantPool();
cgen.addAnnotation(createCombinedAnnotation(cp));
assertTrue("Should now have two annotations but has "+cgen.getAnnotations().length,
cgen.getAnnotations().length==2);
dumpClass(cg,dir+File.separator+fname);
}
- private void buildClassContentsWithAnnotatedMethods(ClassGen cg, ConstantPool cp, InstructionList il) {
+ private void buildClassContentsWithAnnotatedMethods(ClassGen cg, ConstantPoolGen cp, InstructionList il) {
// Create method 'public static void main(String[]argv)'
MethodGen mg = createMethodGen("main",il,cp);
InstructionFactory factory = new InstructionFactory(cg);
LocalVariableGen lg = mg.addLocalVariable("in", new ObjectType(
"java.io.BufferedReader"), null, null);
int in = lg.getIndex();
- lg.setStart(il.append(InstructionFactory.createASTORE(in))); // "in" valid from here
+ lg.setStart(il.append(new ASTORE(in))); // "in" valid from here
// Create local variable name and initialize it to null
lg = mg.addLocalVariable("name", Type.STRING, null, null);
int name = lg.getIndex();
il.append(InstructionConstants.ACONST_NULL);
- lg.setStart(il.append(InstructionFactory.createASTORE(name))); // "name" valid from here
+ lg.setStart(il.append(new ASTORE(name))); // "name" valid from here
// Create try-catch block: We remember the start of the block, read a
// line from the standard input and store it into the variable name .
// il.append(new ALOAD(in));
// il.append(factory.createInvoke("java.io.BufferedReader", "readLine",
// Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
- InstructionHandle try_start = il.append(InstructionFactory.PUSH(cp,"Andy"));
- il.append(InstructionFactory.createASTORE(name));
+ InstructionHandle try_start = il.append(new PUSH(cp,"Andy"));
+ il.append(new ASTORE(name));
// Upon normal execution we jump behind exception handler, the target
// address is not known yet.
- InstructionBranch g = new InstructionBranch(Constants.GOTO);
+ GOTO g = new GOTO(null);
InstructionHandle try_end = il.append(g);
// We add the exception handler which simply returns from the method.
LocalVariableGen var_ex = mg.addLocalVariable("ex",Type.getType("Ljava.io.IOException;"),null,null);
int var_ex_slot = var_ex.getIndex();
- InstructionHandle handler = il.append(InstructionFactory.createASTORE(var_ex_slot));
+ InstructionHandle handler = il.append(new ASTORE(var_ex_slot));
var_ex.setStart(handler);
var_ex.setEnd(il.append(InstructionConstants.RETURN));
il.append(factory.createNew(Type.STRINGBUFFER));
il.append(InstructionConstants.DUP);
- il.append(InstructionFactory.PUSH(cp, "Hello, "));
+ il.append(new PUSH(cp, "Hello, "));
il
.append(factory.createInvoke("java.lang.StringBuffer",
"<init>", Type.VOID, new Type[] { Type.STRING },
Constants.INVOKESPECIAL));
- il.append(InstructionFactory.createALOAD(name));
+ il.append(new ALOAD(name));
il.append(factory.createInvoke("java.lang.StringBuffer", "append",
Type.STRINGBUFFER, new Type[] { Type.STRING },
Constants.INVOKEVIRTUAL));
cg.addEmptyConstructor(Constants.ACC_PUBLIC);
}
- private void buildClassContents(ClassGen cg, ConstantPool cp, InstructionList il) {
+ private void buildClassContents(ClassGen cg, ConstantPoolGen cp, InstructionList il) {
// Create method 'public static void main(String[]argv)'
MethodGen mg = createMethodGen("main",il,cp);
InstructionFactory factory = new InstructionFactory(cg);
LocalVariableGen lg = mg.addLocalVariable("in", new ObjectType(
"java.io.BufferedReader"), null, null);
int in = lg.getIndex();
- lg.setStart(il.append(InstructionFactory.createASTORE(in))); // "in" valid from here
+ lg.setStart(il.append(new ASTORE(in))); // "in" valid from here
// Create local variable name and initialize it to null
lg = mg.addLocalVariable("name", Type.STRING, null, null);
int name = lg.getIndex();
il.append(InstructionConstants.ACONST_NULL);
- lg.setStart(il.append(InstructionFactory.createASTORE(name))); // "name" valid from here
+ lg.setStart(il.append(new ASTORE(name))); // "name" valid from here
// Create try-catch block: We remember the start of the block, read a
// line from the standard input and store it into the variable name .
// il.append(new ALOAD(in));
// il.append(factory.createInvoke("java.io.BufferedReader", "readLine",
// Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
- InstructionHandle try_start = il.append(InstructionFactory.PUSH(cp,"Andy"));
- il.append(InstructionFactory.createASTORE(name));
+ InstructionHandle try_start = il.append(new PUSH(cp,"Andy"));
+ il.append(new ASTORE(name));
// Upon normal execution we jump behind exception handler, the target
// address is not known yet.
- InstructionBranch g = new InstructionBranch(Constants.GOTO);
+ GOTO g = new GOTO(null);
InstructionHandle try_end = il.append(g);
// We add the exception handler which simply returns from the method.
LocalVariableGen var_ex = mg.addLocalVariable("ex",Type.getType("Ljava.io.IOException;"),null,null);
int var_ex_slot = var_ex.getIndex();
- InstructionHandle handler = il.append(InstructionFactory.createASTORE(var_ex_slot));
+ InstructionHandle handler = il.append(new ASTORE(var_ex_slot));
var_ex.setStart(handler);
var_ex.setEnd(il.append(InstructionConstants.RETURN));
il.append(factory.createNew(Type.STRINGBUFFER));
il.append(InstructionConstants.DUP);
- il.append(InstructionFactory.PUSH(cp, "Hello, "));
+ il.append(new PUSH(cp, "Hello, "));
il
.append(factory.createInvoke("java.lang.StringBuffer",
"<init>", Type.VOID, new Type[] { Type.STRING },
Constants.INVOKESPECIAL));
- il.append(InstructionFactory.createALOAD(name));
+ il.append(new ALOAD(name));
il.append(factory.createInvoke("java.lang.StringBuffer", "append",
Type.STRINGBUFFER, new Type[] { Type.STRING },
Constants.INVOKEVIRTUAL));
"<generated>", Constants.ACC_PUBLIC | Constants.ACC_SUPER, null);
}
- private MethodGen createMethodGen(String methodname,InstructionList il,ConstantPool cp) {
+ private MethodGen createMethodGen(String methodname,InstructionList il,ConstantPoolGen cp) {
return new MethodGen(
Constants.ACC_STATIC | Constants.ACC_PUBLIC, // access flags
Type.VOID, // return type
}
- public AnnotationGen createSimpleVisibleAnnotation(ConstantPool cp) {
+ public AnnotationGen createSimpleVisibleAnnotation(ConstantPoolGen cp) {
SimpleElementValueGen evg = new SimpleElementValueGen(
ElementValueGen.PRIMITIVE_INT, cp, 4);
return a;
}
- public AnnotationGen createFruitAnnotation(ConstantPool cp,String aFruit) {
+ public AnnotationGen createFruitAnnotation(ConstantPoolGen cp,String aFruit) {
SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.STRING,cp,aFruit);
ElementNameValuePairGen nvGen = new ElementNameValuePairGen("fruit",evg,cp);
ObjectType t = new ObjectType("SimpleStringAnnotation");
return new AnnotationGen(t,elements,true,cp);
}
- public AnnotationGen createCombinedAnnotation(ConstantPool cp) {
+ public AnnotationGen createCombinedAnnotation(ConstantPoolGen cp) {
// Create an annotation instance
AnnotationGen a = createSimpleVisibleAnnotation(cp);
ArrayElementValueGen array = new ArrayElementValueGen(cp);
return new AnnotationGen(new ObjectType("CombinedAnnotation"),elements,true,cp);
}
- public AnnotationGen createSimpleInvisibleAnnotation(ConstantPool cp) {
+ public AnnotationGen createSimpleInvisibleAnnotation(ConstantPoolGen cp) {
SimpleElementValueGen evg = new SimpleElementValueGen(
ElementValueGen.PRIMITIVE_INT, cp, 4);
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Method;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.classfile.annotation.Annotation;
+import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePair;
import org.aspectj.apache.bcel.util.SyntheticRepository;
for (int i = 0; i < methods.length; i++) {
Method m = methods[i];
- AnnotationGen[] methodAnnotations = m.getAnnotations();
+ Annotation[] methodAnnotations = m.getAnnotations();
if (m.getName().equals(methodname)) {
checkAnnotation(methodAnnotations[0],annotationName,annotationElementName,annotationElementValue);
}
}
- private void checkAnnotation(AnnotationGen a,String name,String elementname,String elementvalue) {
+ private void checkAnnotation(Annotation a,String name,String elementname,String elementvalue) {
assertTrue("Expected annotation to have name "+name+" but it had name "+a.getTypeName(),
a.getTypeName().equals(name));
assertTrue("Expected annotation to have one element but it had "+a.getValues().size(),a.getValues().size()==1);
- ElementNameValuePairGen envp = (ElementNameValuePairGen)a.getValues().get(0);
+ ElementNameValuePair envp = (ElementNameValuePair)a.getValues().get(0);
assertTrue("Expected element name "+elementname+" but was "+envp.getNameString(),
elementname.equals(envp.getNameString()));
assertTrue("Expected element value "+elementvalue+" but was "+envp.getValue().stringifyValue(),
// helper methods
- public void checkValue(AnnotationGen a,String name,String tostring) {
+ public void checkValue(Annotation a,String name,String tostring) {
for (Iterator i = a.getValues().iterator(); i.hasNext();) {
- ElementNameValuePairGen element = (ElementNameValuePairGen) i.next();
+ ElementNameValuePair element = (ElementNameValuePair) i.next();
if (element.getNameString().equals(name)) {
if (!element.getValue().stringifyValue().equals(tostring)) {
fail("Expected element "+name+" to have value "+tostring+" but it had value "+element.getValue().stringifyValue());
import org.aspectj.apache.bcel.classfile.Attribute;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Method;
+import org.aspectj.apache.bcel.classfile.annotation.Annotation;
+import org.aspectj.apache.bcel.generic.ALOAD;
+import org.aspectj.apache.bcel.generic.ASTORE;
import org.aspectj.apache.bcel.generic.ArrayType;
import org.aspectj.apache.bcel.generic.ClassGen;
-import org.aspectj.apache.bcel.classfile.ConstantPool;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ArrayElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValueGen;
-import org.aspectj.apache.bcel.generic.InstructionBranch;
+import org.aspectj.apache.bcel.generic.ConstantPoolGen;
+import org.aspectj.apache.bcel.generic.GOTO;
import org.aspectj.apache.bcel.generic.InstructionConstants;
import org.aspectj.apache.bcel.generic.InstructionFactory;
import org.aspectj.apache.bcel.generic.InstructionHandle;
-import org.aspectj.apache.bcel.generic.InstructionLV;
import org.aspectj.apache.bcel.generic.InstructionList;
import org.aspectj.apache.bcel.generic.LocalVariableGen;
import org.aspectj.apache.bcel.generic.MethodGen;
import org.aspectj.apache.bcel.generic.ObjectType;
+import org.aspectj.apache.bcel.generic.PUSH;
import org.aspectj.apache.bcel.generic.Type;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;
+import org.aspectj.apache.bcel.generic.annotation.ArrayElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.generic.annotation.ElementValueGen;
+import org.aspectj.apache.bcel.generic.annotation.SimpleElementValueGen;
import org.aspectj.apache.bcel.util.SyntheticRepository;
/**
*/
public void testParameterAnnotations_builtOK() {
ClassGen clg = createClassGen("HelloWorld");
- ConstantPool cpg = clg.getConstantPool();
+ ConstantPoolGen cpg = clg.getConstantPool();
InstructionList il = new InstructionList();
buildClassContentsWithAnnotatedMethods(clg,cpg,il,true);
assertTrue("Class should have 2 methods but has "+i,i==2);
Method mainMethod = clg.getMethods()[0];
- AnnotationGen[] annos = mainMethod.getAnnotationsOnParameter(0);
+ Annotation[] annos = mainMethod.getAnnotationsOnParameter(0);
assertTrue("Should be two annotation on the 'argv' parameter to main() but there are "+annos.length,annos.length==2);
assertTrue("This annotation should contain the string 'fruit=Apples' but it is "+annos[0].toString(),
annos[0].toString().indexOf("fruit=Apples")!=-1);
*/
public void testParameterAnnotations_savedAndLoadedOK() throws ClassNotFoundException {
ClassGen clg = createClassGen("HelloWorld");
- ConstantPool cpg = clg.getConstantPool();
+ ConstantPoolGen cpg = clg.getConstantPool();
InstructionList il = new InstructionList();
buildClassContentsWithAnnotatedMethods(clg,cpg,il,true);
assertTrue("Class should have 2 methods but has "+i,i==2);
Method mainMethod = clg.getMethods()[0];
- AnnotationGen[] annos = mainMethod.getAnnotationsOnParameter(0);
+ Annotation[] annos = mainMethod.getAnnotationsOnParameter(0);
assertTrue("Should be two annotation on the 'argv' parameter to main() but there are "+annos.length,annos.length==2);
assertTrue("This annotation should contain the string 'fruit=Apples' but it is "+annos[0].toString(),
annos[0].toString().indexOf("fruit=Apples")!=-1);
JavaClass jc = getClassFrom("testcode.jar","AnnotatedParameters");
ClassGen clg = new ClassGen(jc);
- ConstantPool cpg = clg.getConstantPool();
+ ConstantPoolGen cpg = clg.getConstantPool();
//
// Foo method looks like this:
JavaClass jc2 = getClassFrom("temp2","AnnotatedParameters");
m = jc2.getMethods()[2];
- AnnotationGen[] p1annotations = m.getAnnotationsOnParameter(0);
- AnnotationGen[] p2annotations = m.getAnnotationsOnParameter(1);
+ Annotation[] p1annotations = m.getAnnotationsOnParameter(0);
+ Annotation[] p2annotations = m.getAnnotationsOnParameter(1);
assertTrue("Expected two annotations on the first parameter but found "+p1annotations.length,p1annotations.length==2);
assertTrue("Expected two annotations on the second parameter but found "+p2annotations.length,p2annotations.length==2);
public void testParameterAnnotations_loadedThenModifiedWithInvisibleAnnotationThenSavedAndLoadedOK() throws ClassNotFoundException {
JavaClass jc = getClassFrom("testcode.jar","AnnotatedParameters");
ClassGen clg = new ClassGen(jc);
- ConstantPool cpg = clg.getConstantPool();
+ ConstantPoolGen cpg = clg.getConstantPool();
//
// Foo method looks like this:
JavaClass jc2 = getClassFrom("temp3","AnnotatedParameters");
m = jc2.getMethods()[2];
- AnnotationGen[] p1annotations = m.getAnnotationsOnParameter(0);
- AnnotationGen[] p2annotations = m.getAnnotationsOnParameter(1);
+ Annotation[] p1annotations = m.getAnnotationsOnParameter(0);
+ Annotation[] p2annotations = m.getAnnotationsOnParameter(1);
assertTrue("Expected two annotations on the first parameter but found "+p1annotations.length,p1annotations.length==2);
assertTrue("Expected two annotations on the second parameter but found "+p2annotations.length,p2annotations.length==2);
dumpClass(cg,dir+File.separator+fname);
}
- private void buildClassContentsWithAnnotatedMethods(ClassGen cg, ConstantPool cp, InstructionList il,boolean addParameterAnnotations) {
+ private void buildClassContentsWithAnnotatedMethods(ClassGen cg, ConstantPoolGen cp, InstructionList il,boolean addParameterAnnotations) {
// Create method 'public static void main(String[]argv)'
MethodGen mg = createMethodGen("main",il,cp);
InstructionFactory factory = new InstructionFactory(cg);
LocalVariableGen lg = mg.addLocalVariable("in", new ObjectType(
"java.io.BufferedReader"), null, null);
int in = lg.getIndex();
- lg.setStart(il.append(InstructionFactory.createASTORE(in))); // "in" valid from here
+ lg.setStart(il.append(new ASTORE(in))); // "in" valid from here
// Create local variable name and initialize it to null
lg = mg.addLocalVariable("name", Type.STRING, null, null);
int name = lg.getIndex();
il.append(InstructionConstants.ACONST_NULL);
- lg.setStart(il.append(InstructionFactory.createASTORE(name))); // "name" valid from here
+ lg.setStart(il.append(new ASTORE(name))); // "name" valid from here
// Create try-catch block: We remember the start of the block, read a
// line from the standard input and store it into the variable name .
// il.append(new ALOAD(in));
// il.append(factory.createInvoke("java.io.BufferedReader", "readLine",
// Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
- InstructionHandle try_start = il.append(InstructionFactory.PUSH(cp,"Andy"));
- il.append(InstructionFactory.createASTORE(name));
+ InstructionHandle try_start = il.append(new PUSH(cp,"Andy"));
+ il.append(new ASTORE(name));
// Upon normal execution we jump behind exception handler, the target
// address is not known yet.
- InstructionBranch g = new InstructionBranch(Constants.GOTO);
+ GOTO g = new GOTO(null);
InstructionHandle try_end = il.append(g);
// We add the exception handler which simply returns from the method.
LocalVariableGen var_ex = mg.addLocalVariable("ex",Type.getType("Ljava.io.IOException;"),null,null);
int var_ex_slot = var_ex.getIndex();
- InstructionHandle handler = il.append(InstructionFactory.createASTORE(var_ex_slot));
+ InstructionHandle handler = il.append(new ASTORE(var_ex_slot));
var_ex.setStart(handler);
var_ex.setEnd(il.append(InstructionConstants.RETURN));
il.append(factory.createNew(Type.STRINGBUFFER));
il.append(InstructionConstants.DUP);
- il.append(InstructionFactory.PUSH(cp, "Hello, "));
+ il.append(new PUSH(cp, "Hello, "));
il
.append(factory.createInvoke("java.lang.StringBuffer",
"<init>", Type.VOID, new Type[] { Type.STRING },
Constants.INVOKESPECIAL));
- il.append(new InstructionLV(Constants.ALOAD,name));
+ il.append(new ALOAD(name));
il.append(factory.createInvoke("java.lang.StringBuffer", "append",
Type.STRINGBUFFER, new Type[] { Type.STRING },
Constants.INVOKEVIRTUAL));
cg.addEmptyConstructor(Constants.ACC_PUBLIC);
}
- private void buildClassContents(ClassGen cg, ConstantPool cp, InstructionList il) {
+ private void buildClassContents(ClassGen cg, ConstantPoolGen cp, InstructionList il) {
// Create method 'public static void main(String[]argv)'
MethodGen mg = createMethodGen("main",il,cp);
InstructionFactory factory = new InstructionFactory(cg);
LocalVariableGen lg = mg.addLocalVariable("in", new ObjectType(
"java.io.BufferedReader"), null, null);
int in = lg.getIndex();
- lg.setStart(il.append(InstructionFactory.createASTORE(in))); // "in" valid from here
+ lg.setStart(il.append(new ASTORE(in))); // "in" valid from here
// Create local variable name and initialize it to null
lg = mg.addLocalVariable("name", Type.STRING, null, null);
int name = lg.getIndex();
il.append(InstructionConstants.ACONST_NULL);
- lg.setStart(il.append(InstructionFactory.createASTORE(name))); // "name" valid from here
+ lg.setStart(il.append(new ASTORE(name))); // "name" valid from here
// Create try-catch block: We remember the start of the block, read a
// line from the standard input and store it into the variable name .
// il.append(new ALOAD(in));
// il.append(factory.createInvoke("java.io.BufferedReader", "readLine",
// Type.STRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
- InstructionHandle try_start = il.append(InstructionFactory.PUSH(cp,"Andy"));
- il.append(InstructionFactory.createASTORE(name));
+ InstructionHandle try_start = il.append(new PUSH(cp,"Andy"));
+ il.append(new ASTORE(name));
// Upon normal execution we jump behind exception handler, the target
// address is not known yet.
- InstructionBranch g = new InstructionBranch(Constants.GOTO);
+ GOTO g = new GOTO(null);
InstructionHandle try_end = il.append(g);
// We add the exception handler which simply returns from the method.
LocalVariableGen var_ex = mg.addLocalVariable("ex",Type.getType("Ljava.io.IOException;"),null,null);
int var_ex_slot = var_ex.getIndex();
- InstructionHandle handler = il.append(InstructionFactory.createASTORE(var_ex_slot));
+ InstructionHandle handler = il.append(new ASTORE(var_ex_slot));
var_ex.setStart(handler);
var_ex.setEnd(il.append(InstructionConstants.RETURN));
il.append(factory.createNew(Type.STRINGBUFFER));
il.append(InstructionConstants.DUP);
- il.append(InstructionFactory.PUSH(cp, "Hello, "));
+ il.append(new PUSH(cp, "Hello, "));
il
.append(factory.createInvoke("java.lang.StringBuffer",
"<init>", Type.VOID, new Type[] { Type.STRING },
Constants.INVOKESPECIAL));
- il.append(InstructionFactory.createALOAD(name));
+ il.append(new ALOAD(name));
il.append(factory.createInvoke("java.lang.StringBuffer", "append",
Type.STRINGBUFFER, new Type[] { Type.STRING },
Constants.INVOKEVIRTUAL));
"<generated>", Constants.ACC_PUBLIC | Constants.ACC_SUPER, null);
}
- private MethodGen createMethodGen(String methodname,InstructionList il,ConstantPool cp) {
+ private MethodGen createMethodGen(String methodname,InstructionList il,ConstantPoolGen cp) {
return new MethodGen(
Constants.ACC_STATIC | Constants.ACC_PUBLIC, // access flags
Type.VOID, // return type
}
- public AnnotationGen createSimpleVisibleAnnotation(ConstantPool cp) {
+ public AnnotationGen createSimpleVisibleAnnotation(ConstantPoolGen cp) {
SimpleElementValueGen evg = new SimpleElementValueGen(
ElementValueGen.PRIMITIVE_INT, cp, 4);
return a;
}
- public AnnotationGen createCombinedAnnotation(ConstantPool cp) {
+ public AnnotationGen createCombinedAnnotation(ConstantPoolGen cp) {
// Create an annotation instance
AnnotationGen a = createSimpleVisibleAnnotation(cp);
ArrayElementValueGen array = new ArrayElementValueGen(cp);
return new AnnotationGen(new ObjectType("CombinedAnnotation"),elements,true,cp);
}
- public AnnotationGen createSimpleInvisibleAnnotation(ConstantPool cp) {
+ public AnnotationGen createSimpleInvisibleAnnotation(ConstantPoolGen cp) {
SimpleElementValueGen evg = new SimpleElementValueGen(
ElementValueGen.PRIMITIVE_INT, cp, 4);
import org.aspectj.apache.bcel.classfile.ConstantPool;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Utility;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ArrayElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.ClassElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen;
-import org.aspectj.apache.bcel.classfile.annotation.EnumElementValueGen;
+import org.aspectj.apache.bcel.classfile.annotation.Annotation;
+import org.aspectj.apache.bcel.classfile.annotation.AnnotationElementValue;
+import org.aspectj.apache.bcel.classfile.annotation.ArrayElementValue;
+import org.aspectj.apache.bcel.classfile.annotation.ClassElementValue;
+import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePair;
+import org.aspectj.apache.bcel.classfile.annotation.ElementValue;
+import org.aspectj.apache.bcel.classfile.annotation.EnumElementValue;
+import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValue;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeVisibleAnnotations;
-import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValueGen;
import org.aspectj.apache.bcel.generic.ClassGen;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;
import org.aspectj.apache.bcel.util.SyntheticRepository;
List anns = rva.getAnnotations();
assertTrue("Should be one annotation but found "+anns.size(),
anns.size()==1);
- AnnotationGen ann = (AnnotationGen) anns.get(0);
+ Annotation ann = (Annotation) anns.get(0);
assertTrue("Should be called 'SimpleAnnotation' but was called "+ann.getTypeName(),
ann.getTypeName().equals("SimpleAnnotation"));
List l = ann.getValues();
assertTrue("Should be one value for annotation 'SimpleAnnotation' but found "+l.size(),
l.size()==1);
- ElementNameValuePairGen envp = (ElementNameValuePairGen)l.get(0);
+ ElementNameValuePair envp = (ElementNameValuePair)l.get(0);
assertTrue("Name of element in SimpleAnnotation should be 'id' but it is "+envp.getNameString(),
envp.getNameString().equals("id"));
- SimpleElementValueGen evalue = (SimpleElementValueGen)envp.getValue();
- assertTrue("'id' should be of type int, but it is "+evalue.getElementValueType(),evalue.getElementValueType()==SimpleElementValueGen.PRIMITIVE_INT);
+ SimpleElementValue evalue = (SimpleElementValue)envp.getValue();
+ assertTrue("'id' should be of type int, but it is "+evalue.getElementValueType(),evalue.getElementValueType()==SimpleElementValue.PRIMITIVE_INT);
assertTrue("'id' should have value 4 but it is "+evalue.getValueInt(),
evalue.getValueInt()==4);
}
SyntheticRepository repos = createRepos("testcode.jar");
JavaClass clazz = repos.loadClass("SimpleAnnotatedClass");
ConstantPool pool = clazz.getConstantPool();
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
assertTrue("Expected one annotation on SimpleAnnotatedClass class but got "+anns.length,
anns.length==1);
}
SyntheticRepository repos = createRepos("testcode.jar");
JavaClass clazz = repos.loadClass("SimpleAnnotatedClass");
ConstantPool pool = clazz.getConstantPool();
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
assertTrue("Expected one annotation on SimpleAnnotatedClass class but got "+anns.length,
anns.length==1);
SyntheticRepository repos2 = createRepos(".");
JavaClass clazz2 = repos.loadClass("SimpleAnnotatedClass");
ConstantPool pool2 = clazz2.getConstantPool();
- AnnotationGen[] anns2 = clazz2.getAnnotations();
+ Annotation[] anns2 = clazz2.getAnnotations();
assertTrue("Expected one annotation on SimpleAnnotatedClass class but got "+anns2.length,
anns2.length==1);
}
private void verifyAnnotationStringElement(JavaClass clazz) {
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
assertTrue("should be one annotation but found "+anns.length,anns.length==1);
- AnnotationGen ann = anns[0];
+ Annotation ann = anns[0];
assertTrue("should be called 'AnnotationStringElement' but was called "+ann.getTypeName(),
ann.getTypeName().equals("AnnotationStringElement"));
List l = ann.getValues();
assertTrue("Should be one value but there were "+l.size(),l.size()==1);
- ElementNameValuePairGen nvp = (ElementNameValuePairGen)l.get(0);
+ ElementNameValuePair nvp = (ElementNameValuePair)l.get(0);
assertTrue("Name of element should be 'stringval' but was "+nvp.getNameString(),
nvp.getNameString().equals("stringval"));
- SimpleElementValueGen ev = (SimpleElementValueGen)nvp.getValue();
+ SimpleElementValue ev = (SimpleElementValue)nvp.getValue();
assertTrue("String value should be 'hello' but was '"+ev.getValueString()+"'",
ev.getValueString().equals("hello"));
}
}
private void verifyComplexAnnotation(JavaClass clazz) {
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
assertTrue("Should be one annotation but found "+anns.length,anns.length==1);
- AnnotationGen ann = anns[0];
+ Annotation ann = anns[0];
assertTrue("Should be called 'ComplexAnnotation' but was called "+ann.getTypeName(),
ann.getTypeName().equals("ComplexAnnotation"));
List l = ann.getValues();
}
- private void checkValue(AnnotationGen a,String name,String tostring) {
+ private void checkValue(Annotation a,String name,String tostring) {
for (Iterator i = a.getValues().iterator(); i.hasNext();) {
- ElementNameValuePairGen element = (ElementNameValuePairGen) i.next();
+ ElementNameValuePair element = (ElementNameValuePair) i.next();
if (element.getNameString().equals(name)) {
if (!element.getValue().stringifyValue().equals(tostring)) {
fail("Expected element "+name+" to have value "+tostring+" but it had value "+element.getValue().stringifyValue());
public void testAnnotationClassElementCopying() throws ClassNotFoundException {
SyntheticRepository repos = createRepos("testcode.jar");
JavaClass clazz = repos.loadClass("AnnotatedWithClassClass");
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
ClassGen cg = new ClassGen(clazz);
// Checks we can copy class values in an annotation
new AnnotationGen(anns[0],cg.getConstantPool(),true);
}
private void verifyClassAnnotation(JavaClass clazz) {
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
assertTrue("should be one annotation but found "+anns.length,anns.length==1);
- AnnotationGen ann = anns[0];
+ Annotation ann = anns[0];
assertTrue("should be called 'AnnotationClassElement' but was called "+ann.getTypeName(),
ann.getTypeName().equals("AnnotationClassElement"));
List l = ann.getValues();
assertTrue("Should be one value but there were "+l.size(),l.size()==1);
- ElementNameValuePairGen nvp = (ElementNameValuePairGen)l.get(0);
+ ElementNameValuePair nvp = (ElementNameValuePair)l.get(0);
assertTrue("Name of element should be 'clz' but was "+nvp.getNameString(),
nvp.getNameString().equals("clz"));
- ClassElementValueGen ev = (ClassElementValueGen)nvp.getValue();
+ ClassElementValue ev = (ClassElementValue)nvp.getValue();
assertTrue("String value should be 'Ljava/lang/Integer;' but was '"+ev.getClassString()+"'",
ev.getClassString().equals("Ljava/lang/Integer;"));
}
public void verifyAnnotationEnumElement(JavaClass clazz) {
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
assertTrue("should be one annotation but found "+anns.length,anns.length==1);
- AnnotationGen ann = anns[0];
+ Annotation ann = anns[0];
assertTrue("should be called 'AnnotationEnumElement' but was called "+ann.getTypeName(),
ann.getTypeName().equals("AnnotationEnumElement"));
List l = ann.getValues();
assertTrue("Should be one value but there were "+l.size(),l.size()==1);
- ElementNameValuePairGen nvp = (ElementNameValuePairGen)l.get(0);
+ ElementNameValuePair nvp = (ElementNameValuePair)l.get(0);
assertTrue("Name of element should be 'enumval' but was "+nvp.getNameString(),
nvp.getNameString().equals("enumval"));
- ElementValueGen ev = nvp.getValue();
- assertTrue("Should be of type EnumElementValue but is "+ev,ev instanceof EnumElementValueGen);
- EnumElementValueGen eev = (EnumElementValueGen)ev;
- assertTrue("Should be an enum type value but is "+eev.getElementValueType(),eev.getElementValueType()==SimpleElementValueGen.ENUM_CONSTANT);
+ ElementValue ev = nvp.getValue();
+ assertTrue("Should be of type EnumElementValue but is "+ev,ev instanceof EnumElementValue);
+ EnumElementValue eev = (EnumElementValue)ev;
+ assertTrue("Should be an enum type value but is "+eev.getElementValueType(),eev.getElementValueType()==SimpleElementValue.ENUM_CONSTANT);
assertTrue("Enum type for annotation should be 'SimpleEnum' but is "+Utility.signatureToString(eev.getEnumTypeString()),Utility.signatureToString(eev.getEnumTypeString()).equals("SimpleEnum"));
assertTrue("String value should be 'Red' but was '"+eev.getEnumValueString()+"'",
eev.getEnumValueString().equals("Red"));
public void testAnnotationArraysOfAnnotations() throws ClassNotFoundException {
SyntheticRepository repos = createRepos("testcode.jar");
JavaClass clazz = repos.loadClass("AnnotatedWithCombinedAnnotation");
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
assertTrue("should be one annotation but found "+anns.length,anns.length==1);
checkCombinedAnnotation(anns[0]);
}
public void testAnnotationArraysOfAnnotationsReadWrite() throws ClassNotFoundException, IOException {
SyntheticRepository repos = createRepos("testcode.jar");
JavaClass clazz = repos.loadClass("AnnotatedWithCombinedAnnotation");
- AnnotationGen[] anns = clazz.getAnnotations();
+ Annotation[] anns = clazz.getAnnotations();
assertTrue("should be one annotation but found "+anns.length,anns.length==1);
checkCombinedAnnotation(anns[0]);
SyntheticRepository repos2 = createRepos(".");
JavaClass clazz2 = repos2.loadClass("AnnotatedWithCombinedAnnotation");
- AnnotationGen[] anns2 = clazz2.getAnnotations();
+ Annotation[] anns2 = clazz2.getAnnotations();
assertTrue("should be one annotation but found "+anns2.length,anns2.length==1);
checkCombinedAnnotation(anns2[0]);
}
- private void checkCombinedAnnotation(AnnotationGen ann) {
+ private void checkCombinedAnnotation(Annotation ann) {
assertTrue("should be called 'CombinedAnnotation' but was called "+ann.getTypeName(),
ann.getTypeName().equals("CombinedAnnotation"));
List l = ann.getValues();
assertTrue("Should be one value but there were "+l.size(),l.size()==1);
- ElementNameValuePairGen nvp = (ElementNameValuePairGen)l.get(0);
+ ElementNameValuePair nvp = (ElementNameValuePair)l.get(0);
assertTrue("Name of element should be 'value' but was "+nvp.getNameString(),
nvp.getNameString().equals("value"));
- ElementValueGen ev = nvp.getValue();
- assertTrue("Should be of type ArrayElementValue but is "+ev,ev instanceof ArrayElementValueGen);
- ArrayElementValueGen aev = (ArrayElementValueGen)ev;
+ ElementValue ev = nvp.getValue();
+ assertTrue("Should be of type ArrayElementValue but is "+ev,ev instanceof ArrayElementValue);
+ ArrayElementValue aev = (ArrayElementValue)ev;
assertTrue("Array element value should be of size 1 but is "+aev.getElementValuesArraySize(),
aev.getElementValuesArraySize()==1);
- ElementValueGen[] evs = aev.getElementValuesArray();
+ ElementValue[] evs = aev.getElementValuesArray();
assertTrue("Entry in the array should be AnnotationElementValue but is "+evs[0],
- evs[0] instanceof AnnotationElementValueGen);
- AnnotationElementValueGen inner_ev = (AnnotationElementValueGen)evs[0];
- AnnotationGen a = inner_ev.getAnnotation();
+ evs[0] instanceof AnnotationElementValue);
+ AnnotationElementValue inner_ev = (AnnotationElementValue)evs[0];
+ Annotation a = inner_ev.getAnnotation();
assertTrue("Should be SimpleAnnotation but is "+a.getTypeName(),a.getTypeName().equals("SimpleAnnotation"));
List envps = a.getValues();
assertTrue("Should be one name value pair but found "+envps.size(),envps.size()==1);
- ElementNameValuePairGen envp = (ElementNameValuePairGen) envps.get(0);
+ ElementNameValuePair envp = (ElementNameValuePair) envps.get(0);
assertTrue("Name should be 'id' but it is "+envp.getNameString(),envp.getNameString().equals("id"));
assertTrue("Value of 'id' should be 4 but it is "+envp.getValue().stringifyValue(),
envp.getValue().stringifyValue().equals("4"));
import org.aspectj.apache.bcel.classfile.Attribute;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Method;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.classfile.annotation.Annotation;
+import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePair;
import org.aspectj.apache.bcel.classfile.annotation.RuntimeVisibleParameterAnnotations;
import org.aspectj.apache.bcel.util.SyntheticRepository;
assertTrue("foo takes two parameters, not "+paramAnns.getParameterAnnotations().size(),
paramAnns.getParameterAnnotations().size()==2);
- AnnotationGen[] firstParamAnnotations = paramAnns.getAnnotationsOnParameter(0);
+ Annotation[] firstParamAnnotations = paramAnns.getAnnotationsOnParameter(0);
checkAnnotation(firstParamAnnotations[0],"SimpleAnnotation","id","2");
- AnnotationGen[] secondParamAnnotations = paramAnns.getAnnotationsOnParameter(1);
+ Annotation[] secondParamAnnotations = paramAnns.getAnnotationsOnParameter(1);
checkAnnotation(secondParamAnnotations[0],"SimpleAnnotation","id","3");
checkAnnotation(secondParamAnnotations[1],"AnnotationEnumElement","enumval","Red");
assertTrue("main takes one parameter, not "+paramAnns.getParameterAnnotations().size(),
paramAnns.getParameterAnnotations().size()==1);
- AnnotationGen[] firstParamAnnotations = paramAnns.getAnnotationsOnParameter(0);
+ Annotation[] firstParamAnnotations = paramAnns.getAnnotationsOnParameter(0);
checkAnnotation(firstParamAnnotations[0],"SimpleAnnotation","id","1");
}
}
Method m = methods[i];
if (m.getName().equals("foo")) {
- AnnotationGen[] firstParamAnnotations = m.getAnnotationsOnParameter(0);
+ Annotation[] firstParamAnnotations = m.getAnnotationsOnParameter(0);
checkAnnotation(firstParamAnnotations[0],"SimpleAnnotation","id","2");
- AnnotationGen[] secondParamAnnotations = m.getAnnotationsOnParameter(1);
+ Annotation[] secondParamAnnotations = m.getAnnotationsOnParameter(1);
checkAnnotation(secondParamAnnotations[0],"SimpleAnnotation","id","3");
checkAnnotation(secondParamAnnotations[1],"AnnotationEnumElement","enumval","Red");
}
}
- private void checkAnnotation(AnnotationGen a,String name,String elementname,String elementvalue) {
+ private void checkAnnotation(Annotation a,String name,String elementname,String elementvalue) {
assertTrue("Expected annotation to have name "+name+" but it had name "+a.getTypeName(),
a.getTypeName().equals(name));
assertTrue("Expected annotation to have one element but it had "+a.getValues().size(),a.getValues().size()==1);
- ElementNameValuePairGen envp = (ElementNameValuePairGen)a.getValues().get(0);
+ ElementNameValuePair envp = (ElementNameValuePair)a.getValues().get(0);
assertTrue("Expected element name "+elementname+" but was "+envp.getNameString(),
elementname.equals(envp.getNameString()));
assertTrue("Expected element value "+elementvalue+" but was "+envp.getValue().stringifyValue(),
// helper methods
- public void checkValue(AnnotationGen a,String name,String tostring) {
+ public void checkValue(Annotation a,String name,String tostring) {
for (Iterator i = a.getValues().iterator(); i.hasNext();) {
- ElementNameValuePairGen element = (ElementNameValuePairGen) i.next();
+ ElementNameValuePair element = (ElementNameValuePair) i.next();
if (element.getNameString().equals(name)) {
if (!element.getValue().stringifyValue().equals(tostring)) {
fail("Expected element "+name+" to have value "+tostring+" but it had value "+element.getValue().stringifyValue());
package org.aspectj.apache.bcel.classfile.tests;
import org.aspectj.apache.bcel.classfile.JavaClass;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
import org.aspectj.apache.bcel.generic.ClassGen;
+import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;
public class TypeAnnotationsTest extends BcelTestCase {
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Method;
-import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen;
-import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen;
+import org.aspectj.apache.bcel.classfile.annotation.Annotation;
+import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePair;
import org.aspectj.apache.bcel.util.SyntheticRepository;
// helper methods
- public void checkValue(AnnotationGen a,String name,String tostring) {
+ public void checkValue(Annotation a,String name,String tostring) {
for (Iterator i = a.getValues().iterator(); i.hasNext();) {
- ElementNameValuePairGen element = (ElementNameValuePairGen) i.next();
+ ElementNameValuePair element = (ElementNameValuePair) i.next();
if (element.getNameString().equals(name)) {
if (!element.getValue().stringifyValue().equals(tostring)) {
fail("Expected element "+name+" to have value "+tostring+" but it had value "+element.getValue().stringifyValue());
projects / aspectj.git / commitdiff