reorg package else cannot work

run-all-junit-tests/testsrc/AllTests.java

@@ -27,7 +27,7 @@ public class AllTests extends TestCase {
         suite.addTest(TestingModuleTests.suite());
         suite.addTest(TestingDriversModuleTests.suite());
         suite.addTest(UtilModuleTests.suite());
-        //suite.addTest(BcweaverModuleTests.suite());
+        //suite.addTest(org.aspectj.weaver.BcweaverModuleTests.suite());
         return suite;
     }
 

testing-util/src/org/aspectj/testing/util/TestUtil.java

@@ -261,7 +261,7 @@ public final class TestUtil {
      * @param actualFile the File path to the actual file, if any
      * @return true if the input files are the same, based on per-line comparisons
      */
-    static boolean sameFiles (
+    public static boolean sameFiles (
         IMessageHandler handler,
         File expectedFile, 
         File actualFile) {
@@ -280,7 +280,7 @@ public final class TestUtil {
      * @param path the String path offset from the base directories
      * @return true if the input files are the same, based on per-line comparisons
      */
-    static boolean sameFiles (
+    public static boolean sameFiles (
         IMessageHandler handler,
         File expectedBaseDir, 
         File actualBaseDir, 

testing-util/testsrc/TestingUtilModuleTests.java

@@ -14,7 +14,7 @@
 
 // default package
 
-import org.aspectj.testing.util.UtilTests;
+import org.aspectj.testing.testingutil.UtilTests;
 
 import junit.framework.Test;
 import junit.framework.TestCase;

weaver/src/org/aspectj/weaver/bcel/BcelAdvice.java

@@ -227,6 +227,11 @@ public class BcelAdvice extends Advice {
      * @return
      */
     public boolean mustCheckExceptions() {
+        if (getConcreteAspect() == null) {
+            //FIXME Alex: not sure this is good to default to that.
+            // dig when do we reach that ie not yet concretized
+            return true;
+        }
         return !getConcreteAspect().isAnnotationStyleAspect();
     }
 
@@ -471,7 +476,8 @@ public class BcelAdvice extends Advice {
 	public BcelVar[] getExposedStateAsBcelVars() {
         // ATAJ aspect
         // the closure instantiation has the same mapping as the extracted method from wich it is called
-        if (getConcreteAspect().isAnnotationStyleAspect()) {
+        //FIXME Alex, we should not have to check thru the concreteAspect
+        if (getConcreteAspect()!= null && getConcreteAspect().isAnnotationStyleAspect()) {
             return BcelVar.NONE;
         }
 

weaver/testsrc/org/aspectj/weaver/BcweaverModuleTests.java

@@ -0,0 +1,36 @@
+package org.aspectj.weaver;
+
+/* *******************************************************************
+ * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     PARC     initial implementation 
+ * ******************************************************************/
+
+// default package
+
+import org.aspectj.weaver.tools.ToolsTests;
+
+import junit.framework.*;
+import junit.framework.Test;
+
+public class BcweaverModuleTests extends TestCase {
+
+    public static Test suite() { 
+        TestSuite suite = new TestSuite(BcweaverModuleTests.class.getName());
+        suite.addTest(org.aspectj.weaver.bcel.BcelTests.suite()); 
+        suite.addTest(org.aspectj.weaver.BcweaverTests.suite()); 
+		suite.addTest(org.aspectj.weaver.patterns.PatternsTests.suite()); 
+        suite.addTestSuite(LocaleTest.class);
+        suite.addTest(ToolsTests.suite());
+        return suite;
+    }
+
+    public BcweaverModuleTests(String name) { super(name); }
+
+}  

weaver/testsrc/org/aspectj/weaver/LocaleTest.java

@@ -0,0 +1,43 @@
+package org.aspectj.weaver;
+
+import java.io.IOException;
+import java.util.Locale;
+
+import junit.framework.TestCase;
+
+import org.aspectj.apache.bcel.generic.Instruction;
+import org.aspectj.apache.bcel.util.ByteSequence;
+
+public class LocaleTest extends TestCase {
+
+	public LocaleTest(String name) {
+		super(name);
+	}
+
+	public void testNormalLocale() {
+		doBipush();		
+	}
+
+	public void testTurkishLocale() {
+		Locale def = Locale.getDefault();
+		Locale.setDefault(new Locale("tr", ""));
+		try {
+			doBipush();
+		} finally {
+			Locale.setDefault(def);
+		}
+	}
+	
+	private static void doBipush() {
+		try {
+			Instruction.readInstruction(
+						new ByteSequence(new byte[] { 
+							(byte)16, // bipush 
+							(byte) 3  // data for bipush
+							}));
+		} catch (IOException e) {
+			throw new RuntimeException(e.getMessage());
+		}
+	}
+}
+

weaver/testsrc/org/aspectj/weaver/test/Aspect.java

@@ -0,0 +1,349 @@
+/* This file is part of the compiler and core tools for the AspectJ(tm)
+ * programming language; see http://aspectj.org
+ *
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * either http://www.mozilla.org/MPL/ or http://aspectj.org/MPL/.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is AspectJ.
+ *
+ * The Initial Developer of the Original Code is Palo Alto Research Center,
+ * Incorporated (PARC). Portions created by PARC are are
+ * Copyright (C) 2002 Palo Alto Research Center, Incorporated.
+ * All Rights Reserved.
+ *
+ * Contributor(s):
+ */
+package org.aspectj.weaver.test;
+import java.util.*;
+
+import org.aspectj.runtime.internal.*;
+import org.aspectj.runtime.internal.AroundClosure;
+import org.aspectj.lang.JoinPoint;
+
+public class Aspect {
+
+	public static void ajc_before_0() {
+		System.out.println("before_0");		
+	}
+ 	public static void ajc_before_0(String s) {
+		System.out.println("before_0: " + s);		
+	}
+    public static boolean ajc_around_0(ArrayList s, AroundClosure c) throws Throwable {
+        System.out.println("doing around, got " + s);
+        Object ret = c.run(new Object[] {s}); // proceed(s)
+        return ((Boolean) ret).booleanValue();   
+    }
+
+	public static void ajc_before_0(java.util.ArrayList list) {
+		System.out.println("before_0: " + list);		
+	}
+
+	public static void ajc_before_method_execution() {
+
+	}	
+	public static void ajc_before_method_execution(Object o) {
+		System.out.println("before_method_execution: " + o);
+	}
+
+    public static void ajc_after_method_execution() {
+        System.out.println("after_method_execution");
+    }    
+    public static void ajc_after_method_execution(Object o) {
+        System.out.println("after_method_execution: " + o);
+    }
+    
+    public static void ajc_afterReturning_method_execution() {
+        System.out.println("ajc_afterReturning_method_execution");
+    }           	
+	public static void ajc_afterReturning_method_execution(Object o) {
+		System.out.println("afterReturning_method_execution: " + o);
+	}
+
+    public static void ajc_afterThrowing_method_execution() {
+        System.out.println("ajc_afterThrowing_method_execution");
+    }               
+    public static void ajc_afterThrowing_method_execution(Object o) {
+        System.out.println("afterThrowing_method_execution: " + o);
+    }    
+
+
+
+
+        
+    public static Object ajc_around(AroundClosure closure) throws Throwable {
+        Object ret = closure.run(new Object[] {});
+        return ret;
+    }   
+    
+    public static Object ajc_around(AroundClosure closure, JoinPoint tjp) throws Throwable {
+        System.out.println("thisJoinPoint: " + tjp);
+        Object ret = closure.run(new Object[] {});
+        return ret;
+    }   
+    
+    // ---    
+    
+    
+    public static void ajc_before_method_call() {
+        System.out.println("before_method_call");
+    }    
+    public static void ajc_before_method_call(Object o) {
+        System.out.println("before_method_call: " + o);
+    }
+        
+    public static void ajc_after_method_call() {
+        System.out.println("after_method_call");
+    }    
+    public static void ajc_after_method_call(Object o) {
+        System.out.println("after_method_call: " + o);
+    }       
+	
+    public static void ajc_afterReturning_method_call() {
+        System.out.println("ajc_afterReturning_method_call");
+    }
+	public static void ajc_afterReturning_method_call(Object o) {
+		System.out.println("afterReturning_method_call: " + o);
+	}
+	
+    public static void ajc_afterThrowing_method_call() {
+        System.out.println("ajc_afterThrowing_method_call");
+    }
+    public static void ajc_afterThrowing_method_call(Object o) {
+        System.out.println("afterThrowing_method_call: " + o);
+    }    
+    
+    public static Object ajc_around_method_call(AroundClosure closure) throws Throwable {
+        Object ret = null;
+        for (int i=0; i<3; i++) {
+            System.out.println("enter: " + i);
+            ret = closure.run(new Object[] {});
+        }
+        return ret;
+    }
+    
+    // ----
+
+    public static void ajc_before_constructor_call() {
+        System.out.println("before_constructor_call");
+    }    
+    public static void ajc_before_constructor_call(Object o) {
+        System.out.println("before_constructor_call: " + o);
+    }
+        
+    public static void ajc_after_constructor_call() {
+        System.out.println("after_constructor_call");
+    }    
+    public static void ajc_after_constructor_call(Object o) {
+        System.out.println("after_constructor_call: " + o);
+    }       
+	
+    public static void ajc_afterReturning_constructor_call() {
+        System.out.println("ajc_afterReturning_constructor_call");
+    }
+	public static void ajc_afterReturning_constructor_call(Object o) {
+		System.out.println("afterReturning_constructor_call: " + o);
+	}
+	
+    public static void ajc_afterThrowing_constructor_call() {
+        System.out.println("ajc_afterThrowing_constructor_call");
+    }
+    public static void ajc_afterThrowing_constructor_call(Object o) {
+        System.out.println("afterThrowing_constructor_call: " + o);
+    }    
+    
+    public static Object ajc_around_constructor_call(AroundClosure closure) throws Throwable {
+        Object ret = null;
+        for (int i=0; i<3; i++) {
+            System.out.println("enter: " + i);
+            ret = closure.run(new Object[] {});
+        }
+        return ret;
+    }    
+    // ----
+
+    public static void ajc_before_constructor_execution() {
+        System.out.println("before_constructor_execution");
+    }    
+    public static void ajc_before_constructor_execution(Object o) {
+        System.out.println("before_constructor_execution: " + o);
+    }
+        
+    public static void ajc_after_constructor_execution() {
+        System.out.println("after_constructor_execution");
+    }    
+    public static void ajc_after_constructor_execution(Object o) {
+        System.out.println("after_constructor_execution: " + o);
+    }       
+	
+    public static void ajc_afterReturning_constructor_execution() {
+        System.out.println("ajc_afterReturning_constructor_execution");
+    }
+	public static void ajc_afterReturning_constructor_execution(Object o) {
+		System.out.println("afterReturning_constructor_execution: " + o);
+	}
+	
+    public static void ajc_afterThrowing_constructor_execution() {
+        System.out.println("ajc_afterThrowing_constructor_execution");
+    }
+    public static void ajc_afterThrowing_constructor_execution(Object o) {
+        System.out.println("afterThrowing_constructor_execution: " + o);
+    }    
+    
+    public static Object ajc_around_constructor_execution(AroundClosure closure) throws Throwable {
+        Object ret = null;
+        for (int i=0; i<3; i++) {
+            System.out.println("enter: " + i);
+            ret = closure.run(new Object[] {});
+        }
+        return ret;
+    }    
+    
+    
+    // ---
+
+	
+	public static void ajc_before_field_get() {
+		System.out.println("before_field_get");
+	}   
+    public static void ajc_before_field_get(Object o) {
+        System.out.println("before_field_get: " + o);
+    }
+    
+    public static void ajc_after_field_get() {
+        System.out.println("after_field_get");
+    }    
+    public static void ajc_after_field_get(Object o) {
+        System.out.println("after_field_get: " + o);
+    }
+    
+    public static void ajc_afterReturning_field_get() {
+        System.out.println("afterReturning_field_get");
+    }    
+    public static void ajc_afterReturning_field_get(Object o) {
+        System.out.println("afterReturning_field_get: " + o);
+    }
+
+    public static void ajc_afterThrowing_field_get() {
+        System.out.println("afterThrowing_field_get");
+    }    
+    public static void ajc_afterThrowing_field_get(Object o) {
+        System.out.println("afterThrowing_field_get: " + o);
+    }
+    public static void ajc_afterThrowing_field_get(Throwable t) {
+        System.out.println("afterThrowing_field_get: " + t);
+    }
+
+	public static Object ajc_around_field_get(AroundClosure closure) throws Throwable {
+		Object ret = closure.run(new Object[] {});
+		return ret;
+	}
+	
+   
+    // ---
+
+	
+	public static void ajc_before_field_set() {
+		System.out.println("before_field_set");
+	}   
+    public static void ajc_before_field_set(Object o) {
+        System.out.println("before_field_set: " + o);
+    }
+    
+    public static void ajc_after_field_set() {
+        System.out.println("after_field_set");
+    }    
+    public static void ajc_after_field_set(Object o) {
+        System.out.println("after_field_set: " + o);
+    }
+    
+    public static void ajc_afterReturning_field_set() {
+        System.out.println("afterReturning_field_set");
+    }    
+    public static void ajc_afterReturning_field_set(Object o) {
+        System.out.println("afterReturning_field_set: " + o);
+    }
+
+    public static void ajc_afterThrowing_field_set() {
+        System.out.println("afterThrowing_field_set");
+    }    
+    public static void ajc_afterThrowing_field_set(Object o) {
+        System.out.println("afterThrowing_field_set: " + o);
+    }
+    public static void ajc_afterThrowing_field_set(Throwable t) {
+        System.out.println("afterThrowing_field_set: " + t);
+    }
+
+	public static Object ajc_around_field_set(AroundClosure closure) throws Throwable {
+		Object ret = closure.run(new Object[] {});
+		return ret;
+	}	
+	
+	// don't call this method for callee-side call join points
+	public static void ajc_before(JoinPoint.StaticPart tjp) {
+		System.out.println("before: " + tjp);
+		if (tjp.getSourceLocation() == null) {
+			throw new RuntimeException("didn't want null");
+		}
+		System.out.println("   loc: " + tjp.getSourceLocation());
+	}
+	
+	public static void ajc_before(JoinPoint tjp) {
+		System.out.println("before: " + tjp + " this = " + tjp.getThis() + 
+				" target = " + tjp.getTarget() +
+				" args = " + Arrays.asList(tjp.getArgs()));
+	}
+	
+	// per object stuff
+	
+	private static Map objects = new HashMap();
+	
+	public static void ajc$perObjectBind(Object o) {
+		if (objects.containsKey(o)) return;
+		objects.put(o, new Aspect());
+	}
+	
+	public static boolean hasAspect(Object o) {
+		return objects.containsKey(o);
+	}
+	
+	public static Aspect aspectOf(Object o) {
+		return (Aspect) objects.get(o);
+	}	
+	
+	
+	// per cflow stuff
+	
+	public static void ajc$perCflowPush() {
+		ajc$perCflowStack.pushInstance(new Aspect());
+	}
+	
+	public static boolean hasAspect() {
+		return ajc$perCflowStack.isValid();
+	}
+	
+	public static Aspect aspectOf() {
+		if (ajc$perSingletonInstance != null) return ajc$perSingletonInstance;
+		
+		return (Aspect) ajc$perCflowStack.peekInstance();
+	}
+	
+	public static CFlowStack ajc$perCflowStack = new CFlowStack();
+	
+	// non-static methods
+	
+	public static Aspect ajc$perSingletonInstance = new Aspect();
+	public void ajc_before() {
+		System.out.println("before in: " + this);
+	}
+	
+    public static CFlowStack ajc$cflowStack$0 = new CFlowStack();
+	
+	
+}

weaver/testsrc/org/aspectj/weaver/test/DynamicHelloWorld.java

@@ -0,0 +1,30 @@
+package org.aspectj.weaver.test;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * FIXME regen with an Eclipse 2.1 the testdata/bin with this new package
+ * same for all classes in that package
+ * and update tests then (pointcuts etc)
+ *
+ * @version 	1.0
+ * @author
+ */
+public class DynamicHelloWorld implements Serializable {
+
+    public static void main(String[] args) {
+    	try {
+			new DynamicHelloWorld().doit("hello", Collections.EMPTY_LIST);
+		} catch (UnsupportedOperationException t) {
+			System.out.println("expected and caught: " + t);
+			return;
+		}
+		throw new RuntimeException("should have caught exception");
+    }
+    
+    String doit(String s, List l) {
+    	l.add(s);   // this will throw an exception
+    	return l.toString();
+    }
+}

weaver/testsrc/org/aspectj/weaver/test/FancyHelloWorld.java

@@ -0,0 +1,26 @@
+package org.aspectj.weaver.test;
+
+import java.io.PrintStream;
+
+/**
+ * @version 	1.0
+ * @author
+ */
+public abstract class FancyHelloWorld {
+    public static void main(String[] args) {
+    	PrintStream out = System.out;
+    	try {
+    		out.println("bye");
+    	} catch (Exception e) {
+    		out.println(e);
+    	} finally {
+    		out.println("finally");
+    	}
+    }
+    
+    public static String getName() {
+    	int x = 0;
+    	x += "name".hashCode();
+    	return "name" + x;
+    }
+}

weaver/testsrc/org/aspectj/weaver/test/FieldyHelloWorld.java

@@ -0,0 +1,12 @@
+package org.aspectj.weaver.test;
+
+public class FieldyHelloWorld {
+
+	public static String str = "Hello";
+
+    public static void main(String[] args) {
+        str += " World";
+        
+        System.out.println(str);  
+    }
+}

weaver/testsrc/org/aspectj/weaver/test/HelloWorld.java

@@ -0,0 +1,14 @@
+package org.aspectj.weaver.test;
+
+/**
+ * @version 	1.0
+ * @author
+ */
+public class HelloWorld {
+
+    public static void main(String[] args) {
+        System.out
+        .println("hello world");  
+        //System.out.println("hello world");
+    }
+}

weaver/testsrc/org/aspectj/weaver/test/MultiArgHelloWorld.java

@@ -0,0 +1,12 @@
+package org.aspectj.weaver.test;
+
+public class MultiArgHelloWorld {
+
+    public static void main(String[] args) {
+    	foo("Hello", "World");
+    }
+    
+    static void foo(Object s, Object t) {
+    	System.out.println(s + " " + t);
+    }
+}

weaver/testsrc/org/aspectj/weaver/test/README.txt

@@ -0,0 +1,13 @@
+Those are the source for the
+modules\weaver\testdata\bin
+
+Next time we update the class files in bin\, we have to follow this new package scheme
+(to avoid 'no package' classes floating around)
+
+
+
+
+The class files in this directory are an *input* to the weaver tests. They were generated
+from the .java files in testsrc using an Eclipse 2.1.1 compiler (well, ajc actually). The
+weaver tests are sensitive to implementation details in class file output that vary by compiler.
+When we rev. the jdt.core to 3.0.0 these class files will need to be updated again.

weaver/testsrc/org/aspectj/weaver/test/Test.java

@@ -0,0 +1,13 @@
+package org.aspectj.weaver.test;
+
+public class Test {
+    public static void main(String[] args) {
+        foo()
+        .
+        foo();
+    }
+    public static Test foo() {
+        new Exception().printStackTrace();
+        return new Test();
+    }
+}

weaver/testsrc/org/aspectj/weaver/test/TestSwitchy.java

@@ -0,0 +1,33 @@
+package org.aspectj.weaver.test;
+
+/**
+ * @author hilsdale
+ *
+ * To change this generated comment edit the template variable "typecomment":
+ * Window>Preferences>Java>Templates.
+ * To enable and disable the creation of type comments go to
+ * Window>Preferences>Java>Code Generation.
+ */
+public abstract class TestSwitchy {
+
+
+    public int i = 3;
+    
+    public static final int j = 4;
+    
+    
+    public static void main(String[] args) {
+        switch (args.length) {
+            case 0: System.err.println("hi");
+            case 1: System.err.println("bye"); break;
+            case 2: System.err.println("two");
+            default: System.err.println("ning");
+        }
+        System.err.println("done");
+    }
+    
+    
+    abstract int goo();
+    
+    void nimbo() {}   
+}