From d161bfa34064dcd3b424648e5e8f91a1f10f4023 Mon Sep 17 00:00:00 2001 From: aclement Date: Wed, 22 Feb 2006 15:19:12 +0000 Subject: optimizationasm: some test updates since some weaver tests *really* need BCEL modifiable delegates. --- .../org/aspectj/weaver/bcel/AsmDelegateTests.java | 581 +++++++++++++++++++++ .../testsrc/org/aspectj/weaver/bcel/BcelTests.java | 1 + weaver/testsrc/org/aspectj/weaver/bcel/Perf.java | 146 ++++++ .../org/aspectj/weaver/bcel/UtilityTestCase.java | 1 + .../org/aspectj/weaver/bcel/WeaveTestCase.java | 5 + 5 files changed, 734 insertions(+) create mode 100644 weaver/testsrc/org/aspectj/weaver/bcel/AsmDelegateTests.java create mode 100644 weaver/testsrc/org/aspectj/weaver/bcel/Perf.java (limited to 'weaver/testsrc/org') diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/AsmDelegateTests.java b/weaver/testsrc/org/aspectj/weaver/bcel/AsmDelegateTests.java new file mode 100644 index 000000000..8a6f78e67 --- /dev/null +++ b/weaver/testsrc/org/aspectj/weaver/bcel/AsmDelegateTests.java @@ -0,0 +1,581 @@ +/* ******************************************************************* + * Copyright (c) 2006 Contributors + * All rights reserved. + * This program and the accompanying materials are made available + * under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Andy Clement initial implementation + * ******************************************************************/ + + +package org.aspectj.weaver.bcel; + +import java.io.File; +import java.io.IOException; +import java.util.Enumeration; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +import org.aspectj.weaver.AbstractReferenceTypeDelegate; +import org.aspectj.weaver.AbstractWorldTestCase; +import org.aspectj.weaver.AjAttribute; +import org.aspectj.weaver.AnnotationX; +import org.aspectj.weaver.BcweaverTests; +import org.aspectj.weaver.ReferenceType; +import org.aspectj.weaver.ReferenceTypeDelegate; +import org.aspectj.weaver.ResolvedMember; +import org.aspectj.weaver.ResolvedMemberImpl; +import org.aspectj.weaver.ResolvedType; +import org.aspectj.weaver.ShadowMunger; +import org.aspectj.weaver.TypeVariable; +import org.aspectj.weaver.UnresolvedType; +import org.aspectj.weaver.World; +import org.aspectj.weaver.AjAttribute.EffectiveSignatureAttribute; +import org.aspectj.weaver.asm.AsmDelegate; +import org.aspectj.weaver.asm.AsmField; +import org.aspectj.weaver.asm.AsmMethod; + + +/** + * This is a test case for the nameType parts of worlds. + */ +public class AsmDelegateTests extends AbstractWorldTestCase { + + private final BcelWorld world = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar"); + + public AsmDelegateTests(String name) { + super(name); + } + + protected World getWorld() { + return world; + } + + // --- testcode + + public void testWeDontGoBang() { + ResolvedType rt = world.resolve("SimpleAspect"); + ReferenceTypeDelegate delegate = ((ReferenceType)rt).getDelegate(); + assertTrue("Should be an ASM delegate but is "+delegate.getClass(), + delegate.getClass().toString().equals("class org.aspectj.weaver.asm.AsmDelegate")); + } + + public void testDifferentiatingBetweenAspectAndClass() { + ReferenceType rtAspect = (ReferenceType)world.resolve("SimpleAspect"); + ReferenceType rtString = (ReferenceType)world.resolve("java.lang.String"); + assertTrue("SimpleAspect should be an aspect",rtAspect.isAspect()); + assertTrue("String should not be an aspect",!rtString.isAspect()); + assertTrue("Should be a persingleton "+rtAspect.getPerClause(),rtAspect.getPerClause().toString().startsWith("persingleton")); + } + + public void testRecognizingDifferentTypes() { + ResolvedType rtAnnotation = world.resolve("SimpleAnnotation"); + ResolvedType rtEnum = world.resolve("SimpleEnum"); + ResolvedType rtString = world.resolve("java.lang.String"); + assertTrue("Should be an annotation type",rtAnnotation.isAnnotation()); + assertTrue("Should be an enum type",rtEnum.isEnum()); + assertTrue("Should not be an annotation or enum type",!(rtString.isAnnotation() || rtString.isEnum())); + } + + public void testAnnotationsBehaving() { + ReferenceType rtAnnotation = (ReferenceType)world.resolve("SimpleAnnotation"); + assertTrue("Should be SOURCE but is "+rtAnnotation.getRetentionPolicy(),rtAnnotation.getRetentionPolicy().equals("SOURCE")); + ReferenceType rtAnnotation2 = (ReferenceType)world.resolve("SimpleAnnotation2"); + assertTrue("Should be CLASS but is "+rtAnnotation2.getRetentionPolicy(),rtAnnotation2.getRetentionPolicy().equals("CLASS")); + ReferenceType rtAnnotation3 = (ReferenceType)world.resolve("SimpleAnnotation3"); + assertTrue("Should be RUNTIME but is "+rtAnnotation3.getRetentionPolicy(),rtAnnotation3.getRetentionPolicy().equals("RUNTIME")); + ReferenceType rtAnnotation4 = (ReferenceType)world.resolve("SimpleAnnotation4"); + assertTrue("Should be CLASS but is "+rtAnnotation4.getRetentionPolicy(),rtAnnotation4.getRetentionPolicy().equals("CLASS")); + } + + public void testInterfaceflag() { + ReferenceType rtString = (ReferenceType)world.resolve("java.lang.String"); + assertTrue("String should not be an interface",!rtString.isInterface()); + ReferenceType rtSerializable = (ReferenceType)world.resolve("java.io.Serializable"); + assertTrue("Serializable should be an interface",rtSerializable.isInterface()); + } + + public void testCompareDelegates() { + BcelWorld slowWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar"); + slowWorld.setFastDelegateSupport(false); + BcelWorld fastWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar"); + + ReferenceType bcelList = (ReferenceType)slowWorld.resolve("java.util.List"); + ReferenceType asmList = (ReferenceType)fastWorld.resolve("java.util.List"); + + assertTrue("Should be a bcel delegate? "+bcelList.getDelegate().getClass(), + bcelList.getDelegate().getClass().toString().equals("class org.aspectj.weaver.bcel.BcelObjectType")); + assertTrue("Should be an asm delegate? "+asmList.getDelegate().getClass(), + asmList.getDelegate().getClass().toString().equals("class org.aspectj.weaver.asm.AsmDelegate")); + + TypeVariable[] bcelTVars = bcelList.getTypeVariables(); + + TypeVariable[] asmTVars = asmList.getTypeVariables(); + for (int i = 0; i < asmTVars.length; i++) { + TypeVariable variable = asmTVars[i]; + } + + String bcelsig = bcelList.getSignature(); + String asmsig = asmList.getSignature(); + + assertTrue("Signatures should be the same but "+bcelsig+"!="+asmsig,bcelsig.equals(asmsig)); + + String bcelerasuresig = bcelList.getErasureSignature(); + String asmerasuresig = asmList.getErasureSignature(); + assertTrue("Erasure Signatures should be the same but "+bcelerasuresig+"!="+asmerasuresig,bcelerasuresig.equals(asmerasuresig)); + + ResolvedMember[] bcelfields = bcelList.getDeclaredFields(); + ResolvedMember[] asmfields = asmList.getDeclaredFields(); + if (bcelfields.length!=asmfields.length) { + fail("Dont have the same number of fields? bcel="+bcelfields.length+" asm="+asmfields.length); + } + for (int i = 0; i < asmfields.length; i++) { + ResolvedMember member = asmfields[i]; + if (!bcelfields[i].equals(asmfields[i])) { + fail("Differing fields: "+bcelfields[i]+" and "+asmfields[i]); + } + } + } + + public void testCompareDelegatesComplex() { + BcelWorld slowWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar"); + slowWorld.setFastDelegateSupport(false); + BcelWorld fastWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar"); + + ReferenceType bComplex = (ReferenceType)slowWorld.resolve("Complex"); + ReferenceType aComplex = (ReferenceType)fastWorld.resolve("Complex"); + + checkEquivalent("",(AbstractReferenceTypeDelegate)aComplex.getDelegate(),(AbstractReferenceTypeDelegate)bComplex.getDelegate()); + } + + /** + * Methods are transformed according to generic signatures - this checks + * that some of the generic methods in java.lang.Class appear the same + * whether viewed through an ASM or a BCEL delegate. + */ + public void testCompareGenericMethods() { + BcelWorld slowWorld = new BcelWorld(); + slowWorld.setFastDelegateSupport(false); + slowWorld.setBehaveInJava5Way(true); + + BcelWorld fastWorld = new BcelWorld(); + fastWorld.setBehaveInJava5Way(true); + + ResolvedType bcelJavaLangClass = slowWorld.resolve(UnresolvedType.forName("java.lang.Class")); + ResolvedType asmJavaLangClass = fastWorld.resolve(UnresolvedType.forName("java.lang.Class")); + + bcelJavaLangClass = bcelJavaLangClass.getGenericType(); + asmJavaLangClass = asmJavaLangClass.getGenericType(); + + //if (bcelJavaLangClass == null) return; // for < 1.5 + + ResolvedMember[] bcelMethods = bcelJavaLangClass.getDeclaredMethods(); + ResolvedMember[] asmMethods = asmJavaLangClass.getDeclaredMethods(); + + for (int i = 0; i < bcelMethods.length; i++) { + bcelMethods[i].setParameterNames(null); // forget them, asm delegates dont currently know them + String one = bcelMethods[i].toDebugString(); + String two = asmMethods[i].toDebugString(); + if (!one.equals(two)) { + fail("These methods look different when viewed through ASM or BCEL\nBCEL='"+bcelMethods[i].toDebugString()+ + "'\n ASM='"+asmMethods[i].toDebugString()+"'"); + } + // If one is parameterized, check the other is... + if (bcelMethods[i].canBeParameterized()) { + assertTrue("ASM method '"+asmMethods[i].toDebugString()+"' can't be parameterized whereas its' BCEL variant could", + asmMethods[i].canBeParameterized()); + } + + } + + // Let's take a special look at: + // public Class asSubclass(Class clazz) + ResolvedMember bcelSubclassMethod = null; + for (int i = 0; i < bcelMethods.length; i++) { + if (bcelMethods[i].getName().equals("asSubclass")) { bcelSubclassMethod = bcelMethods[i]; break; } + } + ResolvedMember asmSubclassMethod = null; + for (int i = 0; i < asmMethods.length; i++) { + if (asmMethods[i].getName().equals("asSubclass")) { asmSubclassMethod = asmMethods[i];break; } + } + + TypeVariable[] tvs = bcelSubclassMethod.getTypeVariables(); + assertTrue("should have one type variable on the bcel version but found: "+format(tvs),tvs!=null && tvs.length==1); + tvs = asmSubclassMethod.getTypeVariables(); + assertTrue("should have one type variable on the asm version but found: "+format(tvs),tvs!=null && tvs.length==1); + + } + + private String format(TypeVariable[] tvs) { + if (tvs==null) return "null"; + StringBuffer s = new StringBuffer(); + s.append("["); + for (int i = 0; i < tvs.length; i++) { + s.append(tvs[i]); + if ((i+1)\n"+stringifyStringArray(bcelMemberAttributes)); +// System.err.println(" ASM=>\n"+stringifyStringArray(asmMemberAttributes)); + compareAttributeNames(bcelMemberAttributes,asmMemberAttributes); + + // Let's check the member ones of interest: + + // org.aspectj.weaver.AjSynthetic + if (bmember.isAjSynthetic()) { + assertTrue("Why isnt the ASM method ajsynthetic? "+amember.toDebugString(),amember.isAjSynthetic()); + } else { + assertTrue("Why is the ASM method ajsynthetic? "+amember.toDebugString(),!amember.isAjSynthetic()); + } + + // org.aspectj.weaver.EffectiveSignature + EffectiveSignatureAttribute bcelEsa = bmember.getEffectiveSignature(); + EffectiveSignatureAttribute asmEsa = amember.getEffectiveSignature(); + if (bcelEsa==null) { + assertTrue("Why isnt the ASM effective signature null? "+asmEsa,asmEsa==null); + } else { + if (asmEsa==null) fail("ASM effective signature is null, when BCEL effective signature is "+bcelEsa.toString()); + assertTrue("Should be the same?? b="+bcelEsa.toString()+" a="+asmEsa.toString(),bcelEsa.toString().equals(asmEsa.toString())); + } + + // org.aspectj.weaver.MethodDeclarationLineNumber + int bLine = bmember.getDeclarationLineNumber(); + int aLine = amember.getDeclarationLineNumber(); + assertTrue("Should be the same number: "+bLine+" "+aLine,bLine==aLine); + + + // org.aspectj.weaver.Advice + ShadowMunger bcelSM = bmember.getAssociatedShadowMunger(); + ShadowMunger asmSM = amember.getAssociatedShadowMunger(); + if (bcelSM==null) { + assertTrue("Why isnt the ASM effective signature null? "+asmSM,asmSM==null); + } else { + if (asmSM==null) fail("ASM effective signature is null, when BCEL effective signature is "+bcelSM.toString()); + assertTrue("Should be the same?? b="+bcelSM.toString()+" a="+asmSM.toString(),bcelSM.toString().equals(asmSM.toString())); + } +// new AjASMAttribute("org.aspectj.weaver.SourceContext"), + } + + } + + // @SimpleAnnotation(id=1) int i; + // @SimpleAnnotation(id=2) String s; + public void testLoadingAnnotationsForFields() { + boolean debug = false; + BcelWorld slowWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar");slowWorld.setFastDelegateSupport(false); + BcelWorld fastWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar"); + + ReferenceType bcelT = (ReferenceType)slowWorld.resolve("AnnotatedFields"); + ReferenceType asmT = (ReferenceType)fastWorld.resolve("AnnotatedFields"); + + ResolvedMember[] bcelFields = bcelT.getDeclaredFields(); + ResolvedMember[] asmFields = asmT.getDeclaredFields(); + for (int i = 0; i < bcelFields.length; i++) { + BcelField bmember = (BcelField)bcelFields[i]; + AsmField amember = (AsmField)asmFields[i]; + assertTrue("Seem to be in a muddle. a="+amember.getName()+" b="+bmember.getName(), + amember.getName().equals(bmember.getName())); + if (debug) System.err.println("Looking at "+bmember); + + ResolvedType[] bAnns = bmember.getAnnotationTypes(); + ResolvedType[] aAnns = amember.getAnnotationTypes(); + assertTrue("Should have found an annotation on the bcel field?",bAnns!=null && bAnns.length==1); + assertTrue("Should have found an annotation on the asm field?",aAnns!=null && aAnns.length==1); + + assertTrue("BCEL annotation should be 'SimpleAnnotation3' but is "+bAnns[0].toString(),bAnns[0].toString().equals("SimpleAnnotation3")); + assertTrue("ASM annotation should be 'SimpleAnnotation3' but is "+aAnns[0].toString(),aAnns[0].toString().equals("SimpleAnnotation3")); + + AnnotationX[] bXs = bmember.getAnnotations(); + AnnotationX[] aXs = amember.getAnnotations(); + assertTrue("Should have found an annotation on the bcel field?",bXs!=null && bXs.length==1); + assertTrue("Should have found an annotation on the asm field?",aXs!=null && aXs.length==1); + + String exp = null; + if (i==0) exp = "ANNOTATION [LSimpleAnnotation3;] [runtimeVisible] [id=1]"; + else if (i==1) exp="ANNOTATION [LSimpleAnnotation3;] [runtimeVisible] [id=2]"; + assertTrue("BCEL annotation should be '"+exp+"' but is "+bXs[0].toString(),bXs[0].toString().equals(exp)); + assertTrue("ASM annotation should be '"+exp+"' but is "+aXs[0].toString(),aXs[0].toString().equals(exp)); + } + } + + // @SimpleAnnotation(id=1) + // public void method1() { } + // + // @SimpleAnnotation(id=2) + // public void method2() { } + public void testLoadingAnnotationsForMethods() { + + boolean debug = false; + BcelWorld slowWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar");slowWorld.setFastDelegateSupport(false); + BcelWorld fastWorld = new BcelWorld(BcweaverTests.TESTDATA_PATH+"/forAsmDelegateTesting/stuff.jar"); + + ReferenceType bcelT = (ReferenceType)slowWorld.resolve("AnnotatedMethods"); + ReferenceType asmT = (ReferenceType)fastWorld.resolve("AnnotatedMethods"); + + ResolvedMember[] bcelMethods = bcelT.getDeclaredMethods(); + ResolvedMember[] asmMethods = asmT.getDeclaredMethods(); + for (int i = 0; i < bcelMethods.length; i++) { + + BcelMethod bmember = (BcelMethod)bcelMethods[i]; + AsmMethod amember = (AsmMethod)asmMethods[i]; + if (!bmember.getName().startsWith("method")) continue; + assertTrue("Seem to be in a muddle. a="+amember.getName()+" b="+bmember.getName(), + amember.getName().equals(bmember.getName())); + if (debug) System.err.println("Looking at "+bmember); + + ResolvedType[] bAnns = bmember.getAnnotationTypes(); + ResolvedType[] aAnns = amember.getAnnotationTypes(); + assertTrue("Should have found an annotation on the bcel method?",bAnns!=null && bAnns.length==1); + assertTrue("Should have found an annotation on the asm method?",aAnns!=null && aAnns.length==1); + + assertTrue("BCEL annotation should be 'SimpleAnnotation3' but is "+bAnns[0].toString(),bAnns[0].toString().equals("SimpleAnnotation3")); + assertTrue("ASM annotation should be 'SimpleAnnotation3' but is "+aAnns[0].toString(),aAnns[0].toString().equals("SimpleAnnotation3")); + + AnnotationX[] bXs = bmember.getAnnotations(); + AnnotationX[] aXs = amember.getAnnotations(); + assertTrue("Should have found an annotation on the bcel method?",bXs!=null && bXs.length==1); + assertTrue("Should have found an annotation on the asm method?",aXs!=null && aXs.length==1); + + String exp = null; + if (i==1) exp = "ANNOTATION [LSimpleAnnotation3;] [runtimeVisible] [id=1]"; + else if (i==2) exp="ANNOTATION [LSimpleAnnotation3;] [runtimeVisible] [id=2]"; + assertTrue("BCEL annotation should be '"+exp+"' but is "+bXs[0].toString(),bXs[0].toString().equals(exp)); + assertTrue("ASM annotation should be '"+exp+"' but is "+aXs[0].toString(),aXs[0].toString().equals(exp)); + } + } + + + + private void compareAttributeNames(String[] asmlist,String[] bcellist) { + String astring = stringifyStringArray(asmlist); + String bstring = stringifyStringArray(bcellist); + if (asmlist.length!=bcellist.length) { + fail("Differing lengths.\nBCEL=>\n"+bstring+" ASM=>\n"+astring); + } + } + + private String stringifyStringArray(String[] s) { + StringBuffer r = new StringBuffer(); + for (int i = 0; i < s.length; i++) { + r.append(s[i]).append("\n"); + } + return r.toString(); + } + + +} diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/BcelTests.java b/weaver/testsrc/org/aspectj/weaver/bcel/BcelTests.java index d99d29367..8fca5d6e6 100644 --- a/weaver/testsrc/org/aspectj/weaver/bcel/BcelTests.java +++ b/weaver/testsrc/org/aspectj/weaver/bcel/BcelTests.java @@ -42,6 +42,7 @@ public class BcelTests extends TestCase { suite.addTestSuite(UtilityTestCase.class); suite.addTestSuite(WeaveOrderTestCase.class); suite.addTestSuite(WorldTestCase.class); + suite.addTestSuite(AsmDelegateTests.class); suite.addTestSuite(ZipTestCase.class); //$JUnit-END$ return suite; diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/Perf.java b/weaver/testsrc/org/aspectj/weaver/bcel/Perf.java new file mode 100644 index 000000000..5fab2867a --- /dev/null +++ b/weaver/testsrc/org/aspectj/weaver/bcel/Perf.java @@ -0,0 +1,146 @@ +/* ******************************************************************* + * Copyright (c) 2006 Contributors + * All rights reserved. + * This program and the accompanying materials are made available + * under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Andy Clement IBM initial implementation + * ******************************************************************/ +package org.aspectj.weaver.bcel; + +import java.io.File; +import java.io.IOException; +import java.util.Enumeration; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +import org.aspectj.weaver.ReferenceType; +import org.aspectj.weaver.ResolvedMemberImpl; + +/** + * Compares loading times for bcel and asm - NOT currently pointed at from the suite. + */ +public class Perf { + + public static void main(String[] n) { + + // Two warm up runs, then 3 real runs then print average + //if (n[0].equals("BCEL")) { + long t = timeBcel(); + t = timeBcel(); + + t = timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + t+= timeBcel(); + System.err.println("Average for BCEL (across 16 runs):"+(t/16)+"ms"); + + //} else { + t = timeASM(); + t = timeASM(); + + t = timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + t+= timeASM(); + System.err.println("Average for ASM (across 16 runs):"+(t/16)+"ms"); + //} + } + + private static long timeASM() { + BcelWorld fastWorld = new BcelWorld( + "../lib/aspectj/lib/aspectjtools.jar"); + fastWorld.setBehaveInJava5Way(true); + + try { + File f = new File("../lib/aspectj/lib/aspectjtools.jar"); + ZipFile zf = new ZipFile(f); + int i = 0; + long stime = System.currentTimeMillis(); + Enumeration entries = zf.entries(); + while (entries.hasMoreElements()) { + ZipEntry zfe = (ZipEntry) entries.nextElement(); + String classfileName = zfe.getName(); + if (classfileName.endsWith(".class")) { + String clazzname = classfileName.substring(0, + classfileName.length() - 6).replace('/', '.'); + ReferenceType b = (ReferenceType) fastWorld + .resolve(clazzname); + i++; + } + } + long etime = System.currentTimeMillis(); + System.err.println("asm (" + (etime - stime) + ")"); + // System.err.println();("Successfully compared "+i+" + // entries!!"); + fastWorld.flush(); + return (etime-stime); + } catch (IOException e) { + e.printStackTrace(); + } + return -1; + } + + private static long timeBcel() { + BcelWorld slowWorld = new BcelWorld( + "../lib/aspectj/lib/aspectjtools.jar"); + slowWorld.setFastDelegateSupport(false); + slowWorld.setBehaveInJava5Way(true); + + ResolvedMemberImpl.showParameterNames = false; + try { + File f = new File("../lib/aspectj/lib/aspectjtools.jar"); + // assertTrue("Couldnt find aspectjtools to test. Tried: + // "+f.getAbsolutePath(),f.exists()); + ZipFile zf = new ZipFile(f); + int i = 0; + long stime = System.currentTimeMillis(); + Enumeration entries = zf.entries(); + while (entries.hasMoreElements()) { + ZipEntry zfe = (ZipEntry) entries.nextElement(); + String classfileName = zfe.getName(); + if (classfileName.endsWith(".class")) { + String clazzname = classfileName.substring(0, + classfileName.length() - 6).replace('/', '.'); + ReferenceType b = (ReferenceType) slowWorld + .resolve(clazzname); + i++; + } + } + long etime = System.currentTimeMillis(); + System.err.println("bcel (" + (etime - stime) + ")"); + slowWorld.flush(); + return (etime-stime); + } catch (IOException e) { + e.printStackTrace(); + } + return -1; + } +} diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/UtilityTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/UtilityTestCase.java index 05f5610ae..b458643e3 100644 --- a/weaver/testsrc/org/aspectj/weaver/bcel/UtilityTestCase.java +++ b/weaver/testsrc/org/aspectj/weaver/bcel/UtilityTestCase.java @@ -24,6 +24,7 @@ public class UtilityTestCase extends TestCase { public void disassembleTest(String name) throws IOException { BcelWorld world = new BcelWorld("../weaver/bin"); + world.setFastDelegateSupport(false); world.addPath(WeaveTestCase.classDir); LazyClassGen clazz = new LazyClassGen(BcelWorld.getBcelObjectType(world.resolve(name))); diff --git a/weaver/testsrc/org/aspectj/weaver/bcel/WeaveTestCase.java b/weaver/testsrc/org/aspectj/weaver/bcel/WeaveTestCase.java index 7126acca9..c2843c298 100644 --- a/weaver/testsrc/org/aspectj/weaver/bcel/WeaveTestCase.java +++ b/weaver/testsrc/org/aspectj/weaver/bcel/WeaveTestCase.java @@ -36,6 +36,11 @@ public abstract class WeaveTestCase extends TestCase { public BcelWorld world = new BcelWorld(); { world.addPath(classDir); + // Some of the tests in here rely on comparing output from dumping the delegates - if + // we are using ASM delegates we don't know the names of parameters (they are irrelevant...) + // and are missing from the dumping of asm delegates. This switch ensures we + // continue to use BCEL for these tests. + world.setFastDelegateSupport(false); } public WeaveTestCase(String name) { -- cgit v1.2.3