Added easy to understand test for issue of Class.forName differences

between IBM and SUN's JDKs

Moved a nit-picking part of SourceLocationWithExpr to its own test that
is listed as a known limitation.

3 files changed, 71 insertions, 2 deletions

diff --git a/tests/new/ClassForName.java b/tests/new/ClassForName.java
new file mode 100644
index 000000000..83b8a62c5
--- /dev/null
+++ b/tests/new/ClassForName.java
@@ -0,0 +1,22 @@
+
+import org.aspectj.testing.Tester;
+import java.util.*;
+
+public class ClassForName {
+    public static void main(String[] args) throws ClassNotFoundException {
+    	Class c1 = String[].class;
+    	Class c2 = Class.forName("[Ljava.lang.String;");
+    	Class c3 = ClassForName.class.getClassLoader().loadClass("[Ljava.lang.String;");
+    	
+		Tester.checkEqual(c1, c2, "classes c1, c2");
+		Tester.checkEqual(c2, c3, "classes c2, c3");
+    	
+    	Tester.checkEqual(c1.getComponentType(), String.class, "component");
+    }
+}
+
+aspect A {
+	before(): execution(void main(..)) {
+		System.out.println(thisJoinPointStaticPart);
+	}
+}
diff --git a/tests/new/SourceLocationWithinExpr.java b/tests/new/SourceLocationWithinExpr.java
index 797fc430e..5a6b8234d 100644
--- a/tests/new/SourceLocationWithinExpr.java
+++ b/tests/new/SourceLocationWithinExpr.java
@@ -6,8 +6,8 @@ import org.aspectj.lang.reflect.*;
 /** @testcase PR#885 call source locations within expression */
 public class SourceLocationWithinExpr {
     public static void main (String[] args) {
-        new                  // 9*
-            C()              // 10
+        new C()                 // 9*
+                              // 10
             .                // 11
             getD()           // 12*
             .                // 13
diff --git a/tests/new/SourceLocationWithinExprHard.java b/tests/new/SourceLocationWithinExprHard.java
new file mode 100644
index 000000000..013e1447b
--- /dev/null
+++ b/tests/new/SourceLocationWithinExprHard.java
@@ -0,0 +1,47 @@
+
+import org.aspectj.testing.Tester;
+import org.aspectj.lang.*;
+import org.aspectj.lang.reflect.*;
+
+/** @testcase PR#885 call source locations within expression */
+public class SourceLocationWithinExprHard {
+    public static void main (String[] args) {
+        new                  // 9*
+            C()              // 10
+            .                // 11
+            getD()           // 12*
+            .                // 13
+            getE()           // 14*
+            .                // 15
+            getF()           // 16*
+            ;
+        Tester.expectEvent("setup");
+        Tester.checkAllEvents();
+    } 
+}
+class C { D getD() { return new D(); } }
+class D { E getE() { return new E(); } }
+class E { F getF() { return new F(); } }
+class F { }
+
+aspect A {
+    private static final String SEP = " - ";
+    static {
+        // using qualifying expr?
+        Tester.expectEvent("C()" + SEP + "9");
+        Tester.expectEvent("getD()" + SEP + "12");
+        Tester.expectEvent("getE()" + SEP + "14");
+        Tester.expectEvent("getF()" + SEP + "16");
+        Tester.event("setup");
+    }
+    pointcut filter() : withincode(static void SourceLocationWithinExpr.main(String[]));
+    before() : filter() && call(C.new()) { signal("C()", thisJoinPoint); }
+    before() : filter() && call(D C.getD()) { signal("getD()", thisJoinPoint); }
+    before() : filter() && call(E D.getE()) { signal("getE()", thisJoinPoint); }
+    before() : filter() && call(F E.getF()) { signal("getF()", thisJoinPoint); }
+    void signal(String prefix, JoinPoint jp) {
+        SourceLocation sl = jp.getSourceLocation();
+        System.out.println(prefix + SEP + sl.getLine());
+        Tester.event(prefix + SEP + sl.getLine());
+    }
+}