From b6ae145e2ae12dbe183a9a3b77fff51fc731711b Mon Sep 17 00:00:00 2001 From: aclement Date: Thu, 15 Feb 2007 15:20:52 +0000 Subject: [PATCH] is this going into the branch?!?! --- .../apache/bcel/classfile/tests/AllTests.java | 3 +- .../tests/AnnotationDefaultAttributeTest.java | 8 +- .../classfile/tests/AnnotationGenTest.java | 16 +-- .../bcel/classfile/tests/BcelTestCase.java | 24 ++--- .../classfile/tests/ElementValueGenTest.java | 34 +++---- .../classfile/tests/FieldAnnotationsTest.java | 15 ++- .../tests/GeneratingAnnotatedClassesTest.java | 96 +++++++++--------- .../tests/MethodAnnotationsTest.java | 14 +-- .../tests/ParameterAnnotationsTest.java | 85 ++++++++-------- ...RuntimeVisibleAnnotationAttributeTest.java | 97 +++++++++---------- ...sibleParameterAnnotationAttributeTest.java | 22 ++--- .../classfile/tests/TypeAnnotationsTest.java | 2 +- .../bcel/classfile/tests/VarargsTest.java | 8 +- 13 files changed, 201 insertions(+), 223 deletions(-) diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AllTests.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AllTests.java index da406e725..cf270b5b0 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AllTests.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AllTests.java @@ -31,8 +31,9 @@ import org.aspectj.apache.bcel.classfile.tests.VarargsTest; public class AllTests { public static Test suite() { - TestSuite suite = new TestSuite("Tests for BCEL Java5 support"); + TestSuite suite = new TestSuite("Tests for BCEL"); //$JUnit-BEGIN$ + suite.addTestSuite(Fundamentals.class); suite.addTestSuite(RuntimeVisibleParameterAnnotationAttributeTest.class); suite.addTestSuite(AnnotationDefaultAttributeTest.class); suite.addTestSuite(EnclosingMethodAttributeTest.class); diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationDefaultAttributeTest.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationDefaultAttributeTest.java index ced29d489..2a57bbaac 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationDefaultAttributeTest.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationDefaultAttributeTest.java @@ -15,8 +15,8 @@ package org.aspectj.apache.bcel.classfile.tests; 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.ElementValue; -import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValue; +import org.aspectj.apache.bcel.classfile.annotation.ElementValueGen; +import org.aspectj.apache.bcel.classfile.annotation.SimpleElementValueGen; public class AnnotationDefaultAttributeTest extends BcelTestCase { @@ -35,9 +35,9 @@ public class AnnotationDefaultAttributeTest extends BcelTestCase { Method m = getMethod(clazz,"fruit"); AnnotationDefault a = (AnnotationDefault) findAttribute("AnnotationDefault",m.getAttributes()); - SimpleElementValue val = (SimpleElementValue) a.getElementValue(); + SimpleElementValueGen val = (SimpleElementValueGen) a.getElementValue(); assertTrue("Should be STRING but is "+val.getElementValueType(), - val.getElementValueType()==ElementValue.STRING); + val.getElementValueType()==ElementValueGen.STRING); assertTrue("Should have default of bananas but default is "+val.getValueString(), val.getValueString().equals("bananas")); } diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationGenTest.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationGenTest.java index c863fda83..306a1a387 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationGenTest.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationGenTest.java @@ -21,16 +21,16 @@ import java.util.Vector; 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.generic.ConstantPoolGen; +import org.aspectj.apache.bcel.classfile.ConstantPool; 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 { @@ -50,7 +50,7 @@ public class AnnotationGenTest extends BcelTestCase { // Create the containing class ClassGen cg = createClassGen("HelloWorld"); - ConstantPoolGen cp = cg.getConstantPool(); + ConstantPool cp = cg.getConstantPool(); // Create the simple primitive value '4' of type 'int' SimpleElementValueGen evg = @@ -81,7 +81,7 @@ public class AnnotationGenTest extends BcelTestCase { // Create the containing class ClassGen cg = createClassGen("HelloWorld"); - ConstantPoolGen cp = cg.getConstantPool(); + ConstantPool cp = cg.getConstantPool(); // Create the simple primitive value '4' of type 'int' SimpleElementValueGen evg = @@ -138,7 +138,7 @@ public class AnnotationGenTest extends BcelTestCase { //// // Helper methods - private void checkSerialize(AnnotationGen a,ConstantPoolGen cpg) { + private void checkSerialize(AnnotationGen a,ConstantPool cpg) { try { String beforeName = a.getTypeName(); List beforeValues = a.getValues(); diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/BcelTestCase.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/BcelTestCase.java index db2d1c78c..b8a0b503f 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/BcelTestCase.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/BcelTestCase.java @@ -19,13 +19,12 @@ import java.util.List; 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.ConstantPoolGen; +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.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; @@ -100,17 +99,6 @@ public class BcelTestCase extends TestCase { 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", Type.VOID, new Type[] { Type.STRING }, Constants.INVOKESPECIAL)); - il.append(new ALOAD(name)); + il.append(InstructionFactory.createALOAD(name)); il.append(factory.createInvoke("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] { Type.STRING }, Constants.INVOKEVIRTUAL)); @@ -439,7 +433,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { cg.addEmptyConstructor(Constants.ACC_PUBLIC); } - private void buildClassContents(ClassGen cg, ConstantPoolGen cp, InstructionList il) { + private void buildClassContents(ClassGen cg, ConstantPool cp, InstructionList il) { // Create method 'public static void main(String[]argv)' MethodGen mg = createMethodGen("main",il,cp); InstructionFactory factory = new InstructionFactory(cg); @@ -467,14 +461,14 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { LocalVariableGen lg = mg.addLocalVariable("in", new ObjectType( "java.io.BufferedReader"), null, null); int in = lg.getIndex(); - lg.setStart(il.append(new ASTORE(in))); // "in" valid from here + lg.setStart(il.append(InstructionFactory.createASTORE(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(new ASTORE(name))); // "name" valid from here + lg.setStart(il.append(InstructionFactory.createASTORE(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 . @@ -489,13 +483,13 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { // 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(new PUSH(cp,"Andy")); - il.append(new ASTORE(name)); + InstructionHandle try_start = il.append(InstructionFactory.PUSH(cp,"Andy")); + il.append(InstructionFactory.createASTORE(name)); // Upon normal execution we jump behind exception handler, the target // address is not known yet. - GOTO g = new GOTO(null); + InstructionBranch g = new InstructionBranch(Constants.GOTO); InstructionHandle try_end = il.append(g); // We add the exception handler which simply returns from the method. @@ -503,7 +497,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { LocalVariableGen var_ex = mg.addLocalVariable("ex",Type.getType("Ljava.io.IOException;"),null,null); int var_ex_slot = var_ex.getIndex(); - InstructionHandle handler = il.append(new ASTORE(var_ex_slot)); + InstructionHandle handler = il.append(InstructionFactory.createASTORE(var_ex_slot)); var_ex.setStart(handler); var_ex.setEnd(il.append(InstructionConstants.RETURN)); @@ -522,12 +516,12 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { il.append(factory.createNew(Type.STRINGBUFFER)); il.append(InstructionConstants.DUP); - il.append(new PUSH(cp, "Hello, ")); + il.append(InstructionFactory.PUSH(cp, "Hello, ")); il .append(factory.createInvoke("java.lang.StringBuffer", "", Type.VOID, new Type[] { Type.STRING }, Constants.INVOKESPECIAL)); - il.append(new ALOAD(name)); + il.append(InstructionFactory.createALOAD(name)); il.append(factory.createInvoke("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] { Type.STRING }, Constants.INVOKEVIRTUAL)); @@ -566,7 +560,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { "", Constants.ACC_PUBLIC | Constants.ACC_SUPER, null); } - private MethodGen createMethodGen(String methodname,InstructionList il,ConstantPoolGen cp) { + private MethodGen createMethodGen(String methodname,InstructionList il,ConstantPool cp) { return new MethodGen( Constants.ACC_STATIC | Constants.ACC_PUBLIC, // access flags Type.VOID, // return type @@ -577,7 +571,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { } - public AnnotationGen createSimpleVisibleAnnotation(ConstantPoolGen cp) { + public AnnotationGen createSimpleVisibleAnnotation(ConstantPool cp) { SimpleElementValueGen evg = new SimpleElementValueGen( ElementValueGen.PRIMITIVE_INT, cp, 4); @@ -592,7 +586,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { return a; } - public AnnotationGen createFruitAnnotation(ConstantPoolGen cp,String aFruit) { + public AnnotationGen createFruitAnnotation(ConstantPool cp,String aFruit) { SimpleElementValueGen evg = new SimpleElementValueGen(ElementValueGen.STRING,cp,aFruit); ElementNameValuePairGen nvGen = new ElementNameValuePairGen("fruit",evg,cp); ObjectType t = new ObjectType("SimpleStringAnnotation"); @@ -601,7 +595,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { return new AnnotationGen(t,elements,true,cp); } - public AnnotationGen createCombinedAnnotation(ConstantPoolGen cp) { + public AnnotationGen createCombinedAnnotation(ConstantPool cp) { // Create an annotation instance AnnotationGen a = createSimpleVisibleAnnotation(cp); ArrayElementValueGen array = new ArrayElementValueGen(cp); @@ -612,7 +606,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase { return new AnnotationGen(new ObjectType("CombinedAnnotation"),elements,true,cp); } - public AnnotationGen createSimpleInvisibleAnnotation(ConstantPoolGen cp) { + public AnnotationGen createSimpleInvisibleAnnotation(ConstantPool cp) { SimpleElementValueGen evg = new SimpleElementValueGen( ElementValueGen.PRIMITIVE_INT, cp, 4); diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/MethodAnnotationsTest.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/MethodAnnotationsTest.java index 5b4bbbaa9..005eb3f69 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/MethodAnnotationsTest.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/MethodAnnotationsTest.java @@ -18,8 +18,8 @@ import java.util.Iterator; 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.AnnotationGen; +import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen; import org.aspectj.apache.bcel.util.SyntheticRepository; @@ -65,7 +65,7 @@ public class MethodAnnotationsTest extends BcelTestCase { for (int i = 0; i < methods.length; i++) { Method m = methods[i]; - Annotation[] methodAnnotations = m.getAnnotations(); + AnnotationGen[] methodAnnotations = m.getAnnotations(); if (m.getName().equals(methodname)) { checkAnnotation(methodAnnotations[0],annotationName,annotationElementName,annotationElementValue); @@ -73,11 +73,11 @@ public class MethodAnnotationsTest extends BcelTestCase { } } - private void checkAnnotation(Annotation a,String name,String elementname,String elementvalue) { + private void checkAnnotation(AnnotationGen 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); - ElementNameValuePair envp = (ElementNameValuePair)a.getValues().get(0); + ElementNameValuePairGen envp = (ElementNameValuePairGen)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(), @@ -87,9 +87,9 @@ public class MethodAnnotationsTest extends BcelTestCase { // helper methods - public void checkValue(Annotation a,String name,String tostring) { + public void checkValue(AnnotationGen a,String name,String tostring) { for (Iterator i = a.getValues().iterator(); i.hasNext();) { - ElementNameValuePair element = (ElementNameValuePair) i.next(); + ElementNameValuePairGen element = (ElementNameValuePairGen) 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()); diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/ParameterAnnotationsTest.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/ParameterAnnotationsTest.java index d0afaef41..5df4ea173 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/ParameterAnnotationsTest.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/ParameterAnnotationsTest.java @@ -17,28 +17,25 @@ import org.aspectj.apache.bcel.Constants; 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.generic.ConstantPoolGen; -import org.aspectj.apache.bcel.generic.GOTO; +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.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; /** @@ -66,7 +63,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { */ public void testParameterAnnotations_builtOK() { ClassGen clg = createClassGen("HelloWorld"); - ConstantPoolGen cpg = clg.getConstantPool(); + ConstantPool cpg = clg.getConstantPool(); InstructionList il = new InstructionList(); buildClassContentsWithAnnotatedMethods(clg,cpg,il,true); @@ -75,7 +72,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { assertTrue("Class should have 2 methods but has "+i,i==2); Method mainMethod = clg.getMethods()[0]; - Annotation[] annos = mainMethod.getAnnotationsOnParameter(0); + AnnotationGen[] 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); @@ -90,7 +87,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { */ public void testParameterAnnotations_savedAndLoadedOK() throws ClassNotFoundException { ClassGen clg = createClassGen("HelloWorld"); - ConstantPoolGen cpg = clg.getConstantPool(); + ConstantPool cpg = clg.getConstantPool(); InstructionList il = new InstructionList(); buildClassContentsWithAnnotatedMethods(clg,cpg,il,true); @@ -105,7 +102,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { assertTrue("Class should have 2 methods but has "+i,i==2); Method mainMethod = clg.getMethods()[0]; - Annotation[] annos = mainMethod.getAnnotationsOnParameter(0); + AnnotationGen[] 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); @@ -124,7 +121,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { JavaClass jc = getClassFrom("testcode.jar","AnnotatedParameters"); ClassGen clg = new ClassGen(jc); - ConstantPoolGen cpg = clg.getConstantPool(); + ConstantPool cpg = clg.getConstantPool(); // // Foo method looks like this: @@ -171,8 +168,8 @@ public class ParameterAnnotationsTest extends BcelTestCase { JavaClass jc2 = getClassFrom("temp2","AnnotatedParameters"); m = jc2.getMethods()[2]; - Annotation[] p1annotations = m.getAnnotationsOnParameter(0); - Annotation[] p2annotations = m.getAnnotationsOnParameter(1); + AnnotationGen[] p1annotations = m.getAnnotationsOnParameter(0); + AnnotationGen[] 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); @@ -193,7 +190,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { public void testParameterAnnotations_loadedThenModifiedWithInvisibleAnnotationThenSavedAndLoadedOK() throws ClassNotFoundException { JavaClass jc = getClassFrom("testcode.jar","AnnotatedParameters"); ClassGen clg = new ClassGen(jc); - ConstantPoolGen cpg = clg.getConstantPool(); + ConstantPool cpg = clg.getConstantPool(); // // Foo method looks like this: @@ -242,8 +239,8 @@ public class ParameterAnnotationsTest extends BcelTestCase { JavaClass jc2 = getClassFrom("temp3","AnnotatedParameters"); m = jc2.getMethods()[2]; - Annotation[] p1annotations = m.getAnnotationsOnParameter(0); - Annotation[] p2annotations = m.getAnnotationsOnParameter(1); + AnnotationGen[] p1annotations = m.getAnnotationsOnParameter(0); + AnnotationGen[] 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); @@ -294,7 +291,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { dumpClass(cg,dir+File.separator+fname); } - private void buildClassContentsWithAnnotatedMethods(ClassGen cg, ConstantPoolGen cp, InstructionList il,boolean addParameterAnnotations) { + private void buildClassContentsWithAnnotatedMethods(ClassGen cg, ConstantPool cp, InstructionList il,boolean addParameterAnnotations) { // Create method 'public static void main(String[]argv)' MethodGen mg = createMethodGen("main",il,cp); InstructionFactory factory = new InstructionFactory(cg); @@ -323,14 +320,14 @@ public class ParameterAnnotationsTest extends BcelTestCase { LocalVariableGen lg = mg.addLocalVariable("in", new ObjectType( "java.io.BufferedReader"), null, null); int in = lg.getIndex(); - lg.setStart(il.append(new ASTORE(in))); // "in" valid from here + lg.setStart(il.append(InstructionFactory.createASTORE(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(new ASTORE(name))); // "name" valid from here + lg.setStart(il.append(InstructionFactory.createASTORE(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 . @@ -345,13 +342,13 @@ public class ParameterAnnotationsTest extends BcelTestCase { // 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(new PUSH(cp,"Andy")); - il.append(new ASTORE(name)); + InstructionHandle try_start = il.append(InstructionFactory.PUSH(cp,"Andy")); + il.append(InstructionFactory.createASTORE(name)); // Upon normal execution we jump behind exception handler, the target // address is not known yet. - GOTO g = new GOTO(null); + InstructionBranch g = new InstructionBranch(Constants.GOTO); InstructionHandle try_end = il.append(g); // We add the exception handler which simply returns from the method. @@ -359,7 +356,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { LocalVariableGen var_ex = mg.addLocalVariable("ex",Type.getType("Ljava.io.IOException;"),null,null); int var_ex_slot = var_ex.getIndex(); - InstructionHandle handler = il.append(new ASTORE(var_ex_slot)); + InstructionHandle handler = il.append(InstructionFactory.createASTORE(var_ex_slot)); var_ex.setStart(handler); var_ex.setEnd(il.append(InstructionConstants.RETURN)); @@ -378,12 +375,12 @@ public class ParameterAnnotationsTest extends BcelTestCase { il.append(factory.createNew(Type.STRINGBUFFER)); il.append(InstructionConstants.DUP); - il.append(new PUSH(cp, "Hello, ")); + il.append(InstructionFactory.PUSH(cp, "Hello, ")); il .append(factory.createInvoke("java.lang.StringBuffer", "", Type.VOID, new Type[] { Type.STRING }, Constants.INVOKESPECIAL)); - il.append(new ALOAD(name)); + il.append(new InstructionLV(Constants.ALOAD,name)); il.append(factory.createInvoke("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] { Type.STRING }, Constants.INVOKEVIRTUAL)); @@ -408,7 +405,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { cg.addEmptyConstructor(Constants.ACC_PUBLIC); } - private void buildClassContents(ClassGen cg, ConstantPoolGen cp, InstructionList il) { + private void buildClassContents(ClassGen cg, ConstantPool cp, InstructionList il) { // Create method 'public static void main(String[]argv)' MethodGen mg = createMethodGen("main",il,cp); InstructionFactory factory = new InstructionFactory(cg); @@ -436,14 +433,14 @@ public class ParameterAnnotationsTest extends BcelTestCase { LocalVariableGen lg = mg.addLocalVariable("in", new ObjectType( "java.io.BufferedReader"), null, null); int in = lg.getIndex(); - lg.setStart(il.append(new ASTORE(in))); // "in" valid from here + lg.setStart(il.append(InstructionFactory.createASTORE(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(new ASTORE(name))); // "name" valid from here + lg.setStart(il.append(InstructionFactory.createASTORE(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 . @@ -458,13 +455,13 @@ public class ParameterAnnotationsTest extends BcelTestCase { // 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(new PUSH(cp,"Andy")); - il.append(new ASTORE(name)); + InstructionHandle try_start = il.append(InstructionFactory.PUSH(cp,"Andy")); + il.append(InstructionFactory.createASTORE(name)); // Upon normal execution we jump behind exception handler, the target // address is not known yet. - GOTO g = new GOTO(null); + InstructionBranch g = new InstructionBranch(Constants.GOTO); InstructionHandle try_end = il.append(g); // We add the exception handler which simply returns from the method. @@ -472,7 +469,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { LocalVariableGen var_ex = mg.addLocalVariable("ex",Type.getType("Ljava.io.IOException;"),null,null); int var_ex_slot = var_ex.getIndex(); - InstructionHandle handler = il.append(new ASTORE(var_ex_slot)); + InstructionHandle handler = il.append(InstructionFactory.createASTORE(var_ex_slot)); var_ex.setStart(handler); var_ex.setEnd(il.append(InstructionConstants.RETURN)); @@ -491,12 +488,12 @@ public class ParameterAnnotationsTest extends BcelTestCase { il.append(factory.createNew(Type.STRINGBUFFER)); il.append(InstructionConstants.DUP); - il.append(new PUSH(cp, "Hello, ")); + il.append(InstructionFactory.PUSH(cp, "Hello, ")); il .append(factory.createInvoke("java.lang.StringBuffer", "", Type.VOID, new Type[] { Type.STRING }, Constants.INVOKESPECIAL)); - il.append(new ALOAD(name)); + il.append(InstructionFactory.createALOAD(name)); il.append(factory.createInvoke("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[] { Type.STRING }, Constants.INVOKEVIRTUAL)); @@ -535,7 +532,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { "", Constants.ACC_PUBLIC | Constants.ACC_SUPER, null); } - private MethodGen createMethodGen(String methodname,InstructionList il,ConstantPoolGen cp) { + private MethodGen createMethodGen(String methodname,InstructionList il,ConstantPool cp) { return new MethodGen( Constants.ACC_STATIC | Constants.ACC_PUBLIC, // access flags Type.VOID, // return type @@ -546,7 +543,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { } - public AnnotationGen createSimpleVisibleAnnotation(ConstantPoolGen cp) { + public AnnotationGen createSimpleVisibleAnnotation(ConstantPool cp) { SimpleElementValueGen evg = new SimpleElementValueGen( ElementValueGen.PRIMITIVE_INT, cp, 4); @@ -561,7 +558,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { return a; } - public AnnotationGen createCombinedAnnotation(ConstantPoolGen cp) { + public AnnotationGen createCombinedAnnotation(ConstantPool cp) { // Create an annotation instance AnnotationGen a = createSimpleVisibleAnnotation(cp); ArrayElementValueGen array = new ArrayElementValueGen(cp); @@ -572,7 +569,7 @@ public class ParameterAnnotationsTest extends BcelTestCase { return new AnnotationGen(new ObjectType("CombinedAnnotation"),elements,true,cp); } - public AnnotationGen createSimpleInvisibleAnnotation(ConstantPoolGen cp) { + public AnnotationGen createSimpleInvisibleAnnotation(ConstantPool cp) { SimpleElementValueGen evg = new SimpleElementValueGen( ElementValueGen.PRIMITIVE_INT, cp, 4); diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleAnnotationAttributeTest.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleAnnotationAttributeTest.java index 4c8c463cb..1872aed0f 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleAnnotationAttributeTest.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleAnnotationAttributeTest.java @@ -21,17 +21,16 @@ import org.aspectj.apache.bcel.classfile.Attribute; 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.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.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.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; @@ -60,17 +59,17 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { List anns = rva.getAnnotations(); assertTrue("Should be one annotation but found "+anns.size(), anns.size()==1); - Annotation ann = (Annotation) anns.get(0); + AnnotationGen ann = (AnnotationGen) 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); - ElementNameValuePair envp = (ElementNameValuePair)l.get(0); + ElementNameValuePairGen envp = (ElementNameValuePairGen)l.get(0); assertTrue("Name of element in SimpleAnnotation should be 'id' but it is "+envp.getNameString(), envp.getNameString().equals("id")); - SimpleElementValue evalue = (SimpleElementValue)envp.getValue(); - assertTrue("'id' should be of type int, but it is "+evalue.getElementValueType(),evalue.getElementValueType()==SimpleElementValue.PRIMITIVE_INT); + SimpleElementValueGen evalue = (SimpleElementValueGen)envp.getValue(); + assertTrue("'id' should be of type int, but it is "+evalue.getElementValueType(),evalue.getElementValueType()==SimpleElementValueGen.PRIMITIVE_INT); assertTrue("'id' should have value 4 but it is "+evalue.getValueInt(), evalue.getValueInt()==4); } @@ -79,7 +78,7 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { SyntheticRepository repos = createRepos("testcode.jar"); JavaClass clazz = repos.loadClass("SimpleAnnotatedClass"); ConstantPool pool = clazz.getConstantPool(); - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); assertTrue("Expected one annotation on SimpleAnnotatedClass class but got "+anns.length, anns.length==1); } @@ -88,7 +87,7 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { SyntheticRepository repos = createRepos("testcode.jar"); JavaClass clazz = repos.loadClass("SimpleAnnotatedClass"); ConstantPool pool = clazz.getConstantPool(); - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); assertTrue("Expected one annotation on SimpleAnnotatedClass class but got "+anns.length, anns.length==1); @@ -99,7 +98,7 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { SyntheticRepository repos2 = createRepos("."); JavaClass clazz2 = repos.loadClass("SimpleAnnotatedClass"); ConstantPool pool2 = clazz2.getConstantPool(); - Annotation[] anns2 = clazz2.getAnnotations(); + AnnotationGen[] anns2 = clazz2.getAnnotations(); assertTrue("Expected one annotation on SimpleAnnotatedClass class but got "+anns2.length, anns2.length==1); @@ -135,17 +134,17 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { } private void verifyAnnotationStringElement(JavaClass clazz) { - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); assertTrue("should be one annotation but found "+anns.length,anns.length==1); - Annotation ann = anns[0]; + AnnotationGen 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); - ElementNameValuePair nvp = (ElementNameValuePair)l.get(0); + ElementNameValuePairGen nvp = (ElementNameValuePairGen)l.get(0); assertTrue("Name of element should be 'stringval' but was "+nvp.getNameString(), nvp.getNameString().equals("stringval")); - SimpleElementValue ev = (SimpleElementValue)nvp.getValue(); + SimpleElementValueGen ev = (SimpleElementValueGen)nvp.getValue(); assertTrue("String value should be 'hello' but was '"+ev.getValueString()+"'", ev.getValueString().equals("hello")); } @@ -178,9 +177,9 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { } private void verifyComplexAnnotation(JavaClass clazz) { - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); assertTrue("Should be one annotation but found "+anns.length,anns.length==1); - Annotation ann = anns[0]; + AnnotationGen ann = anns[0]; assertTrue("Should be called 'ComplexAnnotation' but was called "+ann.getTypeName(), ann.getTypeName().equals("ComplexAnnotation")); List l = ann.getValues(); @@ -207,9 +206,9 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { } - private void checkValue(Annotation a,String name,String tostring) { + private void checkValue(AnnotationGen a,String name,String tostring) { for (Iterator i = a.getValues().iterator(); i.hasNext();) { - ElementNameValuePair element = (ElementNameValuePair) i.next(); + ElementNameValuePairGen element = (ElementNameValuePairGen) 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()); @@ -232,7 +231,7 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { public void testAnnotationClassElementCopying() throws ClassNotFoundException { SyntheticRepository repos = createRepos("testcode.jar"); JavaClass clazz = repos.loadClass("AnnotatedWithClassClass"); - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); ClassGen cg = new ClassGen(clazz); // Checks we can copy class values in an annotation new AnnotationGen(anns[0],cg.getConstantPool(),true); @@ -256,17 +255,17 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { } private void verifyClassAnnotation(JavaClass clazz) { - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); assertTrue("should be one annotation but found "+anns.length,anns.length==1); - Annotation ann = anns[0]; + AnnotationGen 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); - ElementNameValuePair nvp = (ElementNameValuePair)l.get(0); + ElementNameValuePairGen nvp = (ElementNameValuePairGen)l.get(0); assertTrue("Name of element should be 'clz' but was "+nvp.getNameString(), nvp.getNameString().equals("clz")); - ClassElementValue ev = (ClassElementValue)nvp.getValue(); + ClassElementValueGen ev = (ClassElementValueGen)nvp.getValue(); assertTrue("String value should be 'Ljava/lang/Integer;' but was '"+ev.getClassString()+"'", ev.getClassString().equals("Ljava/lang/Integer;")); @@ -298,20 +297,20 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { } public void verifyAnnotationEnumElement(JavaClass clazz) { - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); assertTrue("should be one annotation but found "+anns.length,anns.length==1); - Annotation ann = anns[0]; + AnnotationGen 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); - ElementNameValuePair nvp = (ElementNameValuePair)l.get(0); + ElementNameValuePairGen nvp = (ElementNameValuePairGen)l.get(0); assertTrue("Name of element should be 'enumval' but was "+nvp.getNameString(), nvp.getNameString().equals("enumval")); - 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); + 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); 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")); @@ -323,7 +322,7 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { public void testAnnotationArraysOfAnnotations() throws ClassNotFoundException { SyntheticRepository repos = createRepos("testcode.jar"); JavaClass clazz = repos.loadClass("AnnotatedWithCombinedAnnotation"); - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); assertTrue("should be one annotation but found "+anns.length,anns.length==1); checkCombinedAnnotation(anns[0]); } @@ -331,7 +330,7 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { public void testAnnotationArraysOfAnnotationsReadWrite() throws ClassNotFoundException, IOException { SyntheticRepository repos = createRepos("testcode.jar"); JavaClass clazz = repos.loadClass("AnnotatedWithCombinedAnnotation"); - Annotation[] anns = clazz.getAnnotations(); + AnnotationGen[] anns = clazz.getAnnotations(); assertTrue("should be one annotation but found "+anns.length,anns.length==1); checkCombinedAnnotation(anns[0]); @@ -341,7 +340,7 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { SyntheticRepository repos2 = createRepos("."); JavaClass clazz2 = repos2.loadClass("AnnotatedWithCombinedAnnotation"); - Annotation[] anns2 = clazz2.getAnnotations(); + AnnotationGen[] anns2 = clazz2.getAnnotations(); assertTrue("should be one annotation but found "+anns2.length,anns2.length==1); checkCombinedAnnotation(anns2[0]); @@ -349,29 +348,29 @@ public class RuntimeVisibleAnnotationAttributeTest extends BcelTestCase { } - private void checkCombinedAnnotation(Annotation ann) { + private void checkCombinedAnnotation(AnnotationGen 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); - ElementNameValuePair nvp = (ElementNameValuePair)l.get(0); + ElementNameValuePairGen nvp = (ElementNameValuePairGen)l.get(0); assertTrue("Name of element should be 'value' but was "+nvp.getNameString(), nvp.getNameString().equals("value")); - ElementValue ev = nvp.getValue(); - assertTrue("Should be of type ArrayElementValue but is "+ev,ev instanceof ArrayElementValue); - ArrayElementValue aev = (ArrayElementValue)ev; + ElementValueGen ev = nvp.getValue(); + assertTrue("Should be of type ArrayElementValue but is "+ev,ev instanceof ArrayElementValueGen); + ArrayElementValueGen aev = (ArrayElementValueGen)ev; assertTrue("Array element value should be of size 1 but is "+aev.getElementValuesArraySize(), aev.getElementValuesArraySize()==1); - ElementValue[] evs = aev.getElementValuesArray(); + ElementValueGen[] evs = aev.getElementValuesArray(); assertTrue("Entry in the array should be AnnotationElementValue but is "+evs[0], - evs[0] instanceof AnnotationElementValue); - AnnotationElementValue inner_ev = (AnnotationElementValue)evs[0]; - Annotation a = inner_ev.getAnnotation(); + evs[0] instanceof AnnotationElementValueGen); + AnnotationElementValueGen inner_ev = (AnnotationElementValueGen)evs[0]; + AnnotationGen 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); - ElementNameValuePair envp = (ElementNameValuePair) envps.get(0); + ElementNameValuePairGen envp = (ElementNameValuePairGen) 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")); diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleParameterAnnotationAttributeTest.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleParameterAnnotationAttributeTest.java index fad1dad2c..90cf709aa 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleParameterAnnotationAttributeTest.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleParameterAnnotationAttributeTest.java @@ -19,8 +19,8 @@ import java.util.Iterator; 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.classfile.annotation.ElementNameValuePair; +import org.aspectj.apache.bcel.classfile.annotation.AnnotationGen; +import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen; import org.aspectj.apache.bcel.classfile.annotation.RuntimeVisibleParameterAnnotations; import org.aspectj.apache.bcel.util.SyntheticRepository; @@ -46,10 +46,10 @@ public class RuntimeVisibleParameterAnnotationAttributeTest extends BcelTestCase assertTrue("foo takes two parameters, not "+paramAnns.getParameterAnnotations().size(), paramAnns.getParameterAnnotations().size()==2); - Annotation[] firstParamAnnotations = paramAnns.getAnnotationsOnParameter(0); + AnnotationGen[] firstParamAnnotations = paramAnns.getAnnotationsOnParameter(0); checkAnnotation(firstParamAnnotations[0],"SimpleAnnotation","id","2"); - Annotation[] secondParamAnnotations = paramAnns.getAnnotationsOnParameter(1); + AnnotationGen[] secondParamAnnotations = paramAnns.getAnnotationsOnParameter(1); checkAnnotation(secondParamAnnotations[0],"SimpleAnnotation","id","3"); checkAnnotation(secondParamAnnotations[1],"AnnotationEnumElement","enumval","Red"); @@ -60,7 +60,7 @@ public class RuntimeVisibleParameterAnnotationAttributeTest extends BcelTestCase assertTrue("main takes one parameter, not "+paramAnns.getParameterAnnotations().size(), paramAnns.getParameterAnnotations().size()==1); - Annotation[] firstParamAnnotations = paramAnns.getAnnotationsOnParameter(0); + AnnotationGen[] firstParamAnnotations = paramAnns.getAnnotationsOnParameter(0); checkAnnotation(firstParamAnnotations[0],"SimpleAnnotation","id","1"); } } @@ -98,10 +98,10 @@ public class RuntimeVisibleParameterAnnotationAttributeTest extends BcelTestCase Method m = methods[i]; if (m.getName().equals("foo")) { - Annotation[] firstParamAnnotations = m.getAnnotationsOnParameter(0); + AnnotationGen[] firstParamAnnotations = m.getAnnotationsOnParameter(0); checkAnnotation(firstParamAnnotations[0],"SimpleAnnotation","id","2"); - Annotation[] secondParamAnnotations = m.getAnnotationsOnParameter(1); + AnnotationGen[] secondParamAnnotations = m.getAnnotationsOnParameter(1); checkAnnotation(secondParamAnnotations[0],"SimpleAnnotation","id","3"); checkAnnotation(secondParamAnnotations[1],"AnnotationEnumElement","enumval","Red"); @@ -109,11 +109,11 @@ public class RuntimeVisibleParameterAnnotationAttributeTest extends BcelTestCase } } - private void checkAnnotation(Annotation a,String name,String elementname,String elementvalue) { + private void checkAnnotation(AnnotationGen 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); - ElementNameValuePair envp = (ElementNameValuePair)a.getValues().get(0); + ElementNameValuePairGen envp = (ElementNameValuePairGen)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(), @@ -123,9 +123,9 @@ public class RuntimeVisibleParameterAnnotationAttributeTest extends BcelTestCase // helper methods - public void checkValue(Annotation a,String name,String tostring) { + public void checkValue(AnnotationGen a,String name,String tostring) { for (Iterator i = a.getValues().iterator(); i.hasNext();) { - ElementNameValuePair element = (ElementNameValuePair) i.next(); + ElementNameValuePairGen element = (ElementNameValuePairGen) 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()); diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/TypeAnnotationsTest.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/TypeAnnotationsTest.java index 5b2e17af8..dcb36432f 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/TypeAnnotationsTest.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/TypeAnnotationsTest.java @@ -13,8 +13,8 @@ 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 { diff --git a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/VarargsTest.java b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/VarargsTest.java index 52590bf71..a6f8e8021 100644 --- a/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/VarargsTest.java +++ b/bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/VarargsTest.java @@ -18,8 +18,8 @@ import java.util.Iterator; 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.AnnotationGen; +import org.aspectj.apache.bcel.classfile.annotation.ElementNameValuePairGen; import org.aspectj.apache.bcel.util.SyntheticRepository; @@ -77,9 +77,9 @@ public class VarargsTest extends BcelTestCase { // helper methods - public void checkValue(Annotation a,String name,String tostring) { + public void checkValue(AnnotationGen a,String name,String tostring) { for (Iterator i = a.getValues().iterator(); i.hasNext();) { - ElementNameValuePair element = (ElementNameValuePair) i.next(); + ElementNameValuePairGen element = (ElementNameValuePairGen) 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()); -- 2.39.5