mirrors
/
org.aspectj
mirror of https://github.com/eclipse/org.aspectj.git
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 139 Wiki Activity
Browse Source

is this going into the branch?!?!

tags/V1_5_4rc1
aclement 17 years ago
parent
6fe085391a
commit
b6ae145e2a
13 changed files with 201 additions and 223 deletions
Split View Show Diff Stats
  1. 2
    1
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AllTests.java
  2. 4
    4
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationDefaultAttributeTest.java
  3. 8
    8
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationGenTest.java
  4. 6
    18
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/BcelTestCase.java
  5. 17
    17
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/ElementValueGenTest.java
  6. 7
    8
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/FieldAnnotationsTest.java
  7. 45
    51
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/GeneratingAnnotatedClassesTest.java
  8. 7
    7
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/MethodAnnotationsTest.java
  9. 41
    44
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/ParameterAnnotationsTest.java
  10. 48
    49
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleAnnotationAttributeTest.java
  11. 11
    11
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleParameterAnnotationAttributeTest.java
  12. 1
    1
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/TypeAnnotationsTest.java
  13. 4
    4
      bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/VarargsTest.java

+ 2
- 1
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AllTests.java View File

@@ -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);

+ 4
- 4
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationDefaultAttributeTest.java View File

@@ -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"));
}

+ 8
- 8
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/AnnotationGenTest.java View File

@@ -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();

+ 6
- 18
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/BcelTestCase.java View File

@@ -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<as.length) result.append(",");
}
result.append("]");
return result.toString();
}
protected String dumpAnnotations(AnnotationGen[] as) {
StringBuffer result = new StringBuffer();
@@ -136,7 +124,7 @@ public class BcelTestCase extends TestCase {
return result.toString();
}

public AnnotationGen createFruitAnnotation(ConstantPoolGen cp, String aFruit, boolean visibility) {
public AnnotationGen createFruitAnnotation(ConstantPool 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");

+ 17
- 17
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/ElementValueGenTest.java View File

@@ -17,12 +17,12 @@ import java.io.IOException;

import org.aspectj.apache.bcel.Constants;
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.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.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 {

@@ -40,7 +40,7 @@ public class ElementValueGenTest extends BcelTestCase {

public void testCreateIntegerElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -51,7 +51,7 @@ public class ElementValueGenTest extends BcelTestCase {

public void testCreateFloatElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -62,7 +62,7 @@ public class ElementValueGenTest extends BcelTestCase {
public void testCreateDoubleElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -74,7 +74,7 @@ public class ElementValueGenTest extends BcelTestCase {
public void testCreateLongElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -86,7 +86,7 @@ public class ElementValueGenTest extends BcelTestCase {

public void testCreateCharElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -98,7 +98,7 @@ public class ElementValueGenTest extends BcelTestCase {
public void testCreateByteElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -110,7 +110,7 @@ public class ElementValueGenTest extends BcelTestCase {

public void testCreateBooleanElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -122,7 +122,7 @@ public class ElementValueGenTest extends BcelTestCase {

public void testCreateShortElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -139,7 +139,7 @@ public class ElementValueGenTest extends BcelTestCase {

// Create HelloWorld
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool 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
@@ -153,7 +153,7 @@ public class ElementValueGenTest extends BcelTestCase {
public void testCreateEnumElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool cp = cg.getConstantPool();

ObjectType enumType = new ObjectType("SimpleEnum"); // Supports rainbow :)
@@ -176,7 +176,7 @@ public class ElementValueGenTest extends BcelTestCase {
public void testCreateClassElementValue() {
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool cp = cg.getConstantPool();
ObjectType classType = new ObjectType("java.lang.Integer");
@@ -192,7 +192,7 @@ public class ElementValueGenTest extends BcelTestCase {
////
// Helper methods
private void checkSerialize(ElementValueGen evgBefore,ConstantPoolGen cpg) {
private void checkSerialize(ElementValueGen evgBefore,ConstantPool cpg) {
try {
String beforeValue = evgBefore.stringifyValue();
ByteArrayOutputStream baos = new ByteArrayOutputStream();

+ 7
- 8
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/FieldAnnotationsTest.java View File

@@ -18,11 +18,10 @@ import java.util.Iterator;

import org.aspectj.apache.bcel.classfile.Field;
import org.aspectj.apache.bcel.classfile.JavaClass;
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.generic.ClassGen;
import org.aspectj.apache.bcel.generic.FieldGen;
import org.aspectj.apache.bcel.generic.annotation.AnnotationGen;
import org.aspectj.apache.bcel.util.SyntheticRepository;


@@ -105,7 +104,7 @@ public class FieldAnnotationsTest extends BcelTestCase {

for (int i = 0; i < fields.length; i++) {
Field f = fields[i];
Annotation[] fieldAnnotations = f.getAnnotations();
AnnotationGen[] fieldAnnotations = f.getAnnotations();
if (f.getName().equals(fieldname)) {
checkAnnotation(fieldAnnotations[0],annotationName,annotationElementName,annotationElementValue);
@@ -113,11 +112,11 @@ public class FieldAnnotationsTest 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(),
@@ -127,9 +126,9 @@ public class FieldAnnotationsTest 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());

+ 45
- 51
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/GeneratingAnnotatedClassesTest.java View File

@@ -17,15 +17,16 @@ import java.util.List;
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.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;
@@ -33,14 +34,7 @@ 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;

/**
@@ -76,7 +70,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase {

// Create HelloWorld
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool cp = cg.getConstantPool();
InstructionList il = new InstructionList();

cg.addAnnotation(createSimpleVisibleAnnotation(cp));
@@ -88,21 +82,21 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase {
JavaClass jc = getClassFrom(".","HelloWorld");
Annotation[] as = jc.getAnnotations();
AnnotationGen[] as = jc.getAnnotations();
assertTrue("Should be two annotations but found "+as.length,as.length==2);
Annotation one = as[0];
Annotation two = as[1];
AnnotationGen one = as[0];
AnnotationGen 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();
ElementNameValuePair nvp = (ElementNameValuePair) vals.get(0);
ElementNameValuePairGen nvp = (ElementNameValuePairGen) vals.get(0);
assertTrue("Name of element in SimpleAnnotation should be 'id' but it is "+
nvp.getNameString(),nvp.getNameString().equals("id"));
ElementValue ev = nvp.getValue();
ElementValueGen ev = nvp.getValue();
assertTrue("Type of element value should be int but it is "+ev.getElementValueType(),
ev.getElementValueType()==ElementValue.PRIMITIVE_INT);
ev.getElementValueType()==ElementValueGen.PRIMITIVE_INT);
assertTrue("Value of element should be 4 but it is "+ev.stringifyValue(),
ev.stringifyValue().equals("4"));
assertTrue(createTestdataFile("HelloWorld.class").delete());
@@ -117,7 +111,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase {
public void testGenerateMethodLevelAnnotations1() throws ClassNotFoundException {
// Create HelloWorld
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool cp = cg.getConstantPool();
InstructionList il = new InstructionList();

buildClassContentsWithAnnotatedMethods(cg, cp, il);
@@ -158,7 +152,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase {
public void testGenerateMethodLevelAnnotations2() throws ClassNotFoundException {
// Create HelloWorld
ClassGen cg = createClassGen("HelloWorld");
ConstantPoolGen cp = cg.getConstantPool();
ConstantPool cp = cg.getConstantPool();
InstructionList il = new InstructionList();

buildClassContentsWithAnnotatedMethods(cg, cp, il);
@@ -247,9 +241,9 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase {
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.getElementValuesSize(),
arrayValue.getElementValuesSize()==1);
ElementValueGen innerValue = (ElementValueGen)arrayValue.getElementValues().get(0);
assertTrue("Array value should be size one but is "+arrayValue.getElementValuesArraySize(),
arrayValue.getElementValuesArraySize()==1);
ElementValueGen innerValue = (ElementValueGen)arrayValue.getElementValuesArray()[0];
assertTrue("Value in the array should be AnnotationElementValueGen but is "+innerValue,
innerValue instanceof AnnotationElementValueGen);
AnnotationElementValueGen innerAnnotationValue = (AnnotationElementValueGen)innerValue;
@@ -287,7 +281,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase {
public void testModifyingClasses1() throws ClassNotFoundException {
JavaClass jc = getClassFrom("testcode.jar","SimpleAnnotatedClass");
ClassGen cgen = new ClassGen(jc);
ConstantPoolGen cp = cgen.getConstantPool();
ConstantPool cp = cgen.getConstantPool();
cgen.addAnnotation(createFruitAnnotation(cp,"Pineapple"));
assertTrue("Should now have two annotations but has "+cgen.getAnnotations().length,
cgen.getAnnotations().length==2);
@@ -301,7 +295,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase {
public void testModifyingClasses2() throws ClassNotFoundException {
JavaClass jc = getClassFrom("testcode.jar","SimpleAnnotatedClass");
ClassGen cgen = new ClassGen(jc);
ConstantPoolGen cp = cgen.getConstantPool();
ConstantPool cp = cgen.getConstantPool();
cgen.addAnnotation(createCombinedAnnotation(cp));
assertTrue("Should now have two annotations but has "+cgen.getAnnotations().length,
cgen.getAnnotations().length==2);
@@ -327,7 +321,7 @@ public class GeneratingAnnotatedClassesTest extends BcelTestCase {
dumpClass(cg,dir+File.separator+fname);
}

private void buildClassContentsWithAnnotatedMethods(ClassGen cg, ConstantPoolGen cp, InstructionList il) {
private void buildClassContentsWithAnnotatedMethods(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);
@@ -356,14 +350,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 .
@@ -378,13 +372,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.
@@ -392,7 +386,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));
@@ -411,12 +405,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",
"<init>", 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",
"<init>", 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 {
"<generated>", 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);


+ 7
- 7
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/MethodAnnotationsTest.java View File

@@ -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());

+ 41
- 44
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/ParameterAnnotationsTest.java View File

@@ -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",
"<init>", 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",
"<init>", 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 {
"<generated>", 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);


+ 48
- 49
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleAnnotationAttributeTest.java View File

@@ -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"));

+ 11
- 11
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/RuntimeVisibleParameterAnnotationAttributeTest.java View File

@@ -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());

+ 1
- 1
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/TypeAnnotationsTest.java View File

@@ -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 {

+ 4
- 4
bcel-builder/testsrc/org/aspectj/apache/bcel/classfile/tests/VarargsTest.java View File

@@ -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());

Write Preview
Loading…
Cancel
Save