test cases for after throwing and after returning with generic and parameterized types.

7 files changed, 270 insertions, 0 deletions

diff --git a/tests/java5/generics/afterAdvice/AfterReturningListOfSomething.aj b/tests/java5/generics/afterAdvice/AfterReturningListOfSomething.aj
new file mode 100644
index 000000000..6d10b077a
--- /dev/null
+++ b/tests/java5/generics/afterAdvice/AfterReturningListOfSomething.aj
@@ -0,0 +1,51 @@
+import java.util.*;
+
+public aspect AfterReturningListOfSomething {
+	
+	// returning(List<?>) matches List, List<String>, List<?>, ...
+		
+	List rawList(List l) { return l;}
+	List listOfString(List<String> ls) { return ls; }
+	List listOfSomething(List<?> ls) { return ls; }
+	List listOfSomethingExtends(List<? extends Number> ln) { return ln; }
+	List listOfSomethingSuper(List<? super Double> ln) { return ln; }
+	
+	// try a couple of nested variations too
+	Map<List<String>,List<List<Float>>> mapit(Map<List<String>,List<List<Float>>> m) { return m;}
+	HashSet<Double> setOf(HashSet<Double> sd) { return sd; }
+	
+	public static void main(String[] args) {
+		AfterReturningListOfSomething a = AfterReturningListOfSomething.aspectOf();
+		a.rawList(null);
+		a.listOfString(null);
+		a.listOfSomething(null);
+		a.listOfSomethingExtends(null);
+		a.listOfSomethingSuper(null);
+		a.mapit(null);
+		a.setOf(null);
+	}
+	
+	after() returning(List<?> aList) : execution(* *(..)) {
+		System.out.println("List<?> matches " + thisJoinPointStaticPart);
+	}
+	
+	after() returning(Map<?,?> aMap) : execution(* *(..)) {
+		System.out.println("wild map matches " + thisJoinPointStaticPart);
+	}
+	@org.aspectj.lang.annotation.SuppressAjWarnings
+	after() returning(HashMap<List<?>,List<List<?>>> aMap) : execution(* *(..)) {
+		System.out.println("nested wild map does not match " + thisJoinPointStaticPart);
+	}
+	
+	after() returning(Map<List<String>,List<List<Float>>> aMap) : execution(* *(..)) {
+		System.out.println("exact wild map matches " + thisJoinPointStaticPart);
+	}
+	
+	after() returning(Set<Double> aSet) : execution(* *(..)) {
+		System.out.println("super type exact matches " + thisJoinPointStaticPart);
+	}
+	
+	after() returning(Set<?> aSet) : execution(* *(..)) {
+		System.out.println("super wild type matches " + thisJoinPointStaticPart);
+	}
+}
\ No newline at end of file
diff --git a/tests/java5/generics/afterAdvice/AfterReturningListOfSomethingExtends.aj b/tests/java5/generics/afterAdvice/AfterReturningListOfSomethingExtends.aj
new file mode 100644
index 000000000..4ddcfdc93
--- /dev/null
+++ b/tests/java5/generics/afterAdvice/AfterReturningListOfSomethingExtends.aj
@@ -0,0 +1,31 @@
+import java.util.*;
+
+public aspect AfterReturningListOfSomethingExtends {
+	
+	 // returning(List<? extends Number) matches List<Number>, List<Double>, not List<String>
+	 //                             matches List, List<?> with unchecked warning
+
+	List rawList(List l) { return l; }
+	List<String> listOfString(List<String> ls) { return ls; }
+	List<Number> listOfNumber(List<Number> ln) { return ln; }
+	List<Double> listOfDouble(List<Double> ld) { return ld; }
+	List<?> listOfSomething(List<?> ls) { return ls; }
+	List<? extends Number> listOfSomethingExtends(List<? extends Number> ln) { return ln; }
+	List<? super Double> listOfSomethingSuper(List<? super Double> ln) { return ln; }
+	
+	public static void main(String[] args) {
+		AfterReturningListOfSomethingExtends a = AfterReturningListOfSomethingExtends.aspectOf();
+		a.rawList(new ArrayList());
+		a.listOfString(null);
+		a.listOfNumber(null);
+		a.listOfDouble(null);
+		a.listOfSomething(new ArrayList());
+		a.listOfSomethingExtends(null);
+		a.listOfSomethingSuper(null);
+	}
+	
+	after() returning(List<? extends Number> ln) : execution(* *(..)) {
+		System.out.println("List<? extends Number> matches " + thisJoinPointStaticPart);
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/java5/generics/afterAdvice/AfterReturningListOfSomethingSuper.aj b/tests/java5/generics/afterAdvice/AfterReturningListOfSomethingSuper.aj
new file mode 100644
index 000000000..f877c3603
--- /dev/null
+++ b/tests/java5/generics/afterAdvice/AfterReturningListOfSomethingSuper.aj
@@ -0,0 +1,36 @@
+import java.util.*;
+
+public aspect AfterReturningListOfSomethingSuper {
+	
+	/*
+ 	 *   - returning(List<? super Number>) matches List<Object>, List<Number>
+     *	                              does not match List<Double>
+	 *                                matches List, List<?> with unchecked warning
+	 *                                matches List<? super Number>
+	 *                                matches List<? extends Number> with unchecked warning
+	 */
+	
+	List rawList(List l) { return l; }
+	List<Object> listOfObject(List<Object> ls) { return ls; }
+	List<Number> listOfNumber(List<Number> ln) { return ln; }
+	List<Double> listOfDouble(List<Double> ld) { return ld; }
+	List<?> listOfSomething(List<?> ls) { return ls; }
+	List<? super Number> listOfSomethingSuper(List<? super Number> ln) {return ln; }
+	List<? extends Number> listOfSomethingExtendsNumber(List<? extends Number> ln) { return ln; }
+	
+	public static void main(String[] args) {
+		AfterReturningListOfSomethingSuper a = AfterReturningListOfSomethingSuper.aspectOf();
+		a.rawList(new ArrayList());
+		a.listOfObject(null);
+		a.listOfNumber(null);
+		a.listOfDouble(null);
+		a.listOfSomething(new ArrayList());
+		a.listOfSomethingSuper(null);
+		a.listOfSomethingExtendsNumber(new ArrayList<Double>());
+	}
+	
+	after() returning(List<? super Number> ln) : execution(* *(..)) {
+		System.out.println("List<? super Number> matches " + thisJoinPointStaticPart);
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/java5/generics/afterAdvice/AfterReturningParameterized.aj b/tests/java5/generics/afterAdvice/AfterReturningParameterized.aj
new file mode 100644
index 000000000..716379da1
--- /dev/null
+++ b/tests/java5/generics/afterAdvice/AfterReturningParameterized.aj
@@ -0,0 +1,65 @@
+import java.util.*;
+/**
+ *   - returning(List<String>) matches List<String> but not List<Number>
+ *   - returning(List<String>) matches List with unchecked warning
+ *   - returning(List<String>) matches List<?> with unchecked warning
+ *   - returning(List<String>) matches List<T> with unchecked warning
+ *   - returning(List<String>) matches List<T extends String> (String is final)
+ */
+public aspect AfterReturningParameterized {
+
+	public static void main(String[] args) {
+		 List<String> ls = new ArrayList<String>();
+//		 ls.add("one");
+//		 ls.add("two");
+//		 ls.add("three");
+		 
+		 Generic<String> g = new Generic<String>();
+		 g.foo(ls);
+		 g.bar(ls);
+		 g.tada(ls);
+		 g.afar(new ArrayList<Number>());
+		 g.something(ls);
+		 
+		 MustBeString<String> mbs = new MustBeString<String>();
+		 mbs.listit(ls);
+	 }
+	
+	after() returning(List<String> ls) : call(* *(..))  {
+		System.out.println("returning(List<String> matched at " + thisJoinPointStaticPart);
+		ls.add("four");
+		String s = ls.get(0);
+	}
+	
+}
+
+class Generic<T> {
+	
+	List<T> foo(List<T> lt) {
+		return lt;
+	}
+	
+	List<String> bar(List<String> ls) {
+		return ls;
+	}
+	
+	List tada(List l) {
+		return l;
+	}
+	
+	List<Number> afar(List<Number> ln) {
+		return ln;
+	}
+	
+	List<?> something(List<?> ls) {
+		return ls;
+	}
+}
+
+class MustBeString<T extends String> {
+	
+	List<T> listit(List<T> lt) {
+		return lt;
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/java5/generics/afterAdvice/AfterReturningParameterizedWithWildcards.aj b/tests/java5/generics/afterAdvice/AfterReturningParameterizedWithWildcards.aj
new file mode 100644
index 000000000..57bfd4531
--- /dev/null
+++ b/tests/java5/generics/afterAdvice/AfterReturningParameterizedWithWildcards.aj
@@ -0,0 +1,40 @@
+import java.util.*;
+
+public aspect AfterReturningParameterizedWithWildcards {
+
+	/*
+	 *   - returning(List<Double>) matches List, List<?>, List<? extends Number> with unchecked warning
+	 *                        matches List<Double>, List<? extends Double> ok (since Double is final)
+	 */
+
+	after() returning(List<Double> ld) : call(* *(..)) {
+		System.out.println("List<Double> matched at " + thisJoinPointStaticPart);
+	}
+	
+	public static void main(String[] args) {
+		C c = new C();
+		List<Double> ld = new ArrayList<Double>();
+		c.rawList(ld);
+		c.listOfSomething(ld);
+		c.listOfSomeNumber(ld);
+		c.listOfDouble(ld);
+		c.listOfSomeDouble(ld);
+		c.listOfString(new ArrayList<String>());
+	}
+}
+
+class C {
+	
+	List rawList(List l) { return l;}
+	
+	List<?> listOfSomething(List<?> ls) { return ls; }
+	
+	List<? extends Number> listOfSomeNumber(List<? extends Number> ln) { return ln; }
+	
+	List<Double> listOfDouble(List<Double> ld) { return ld; }
+	
+	List<? extends Double> listOfSomeDouble(List<? extends Double> ld) { return ld; }
+	
+	List<String> listOfString(List<String> ls) { return ls; }
+	
+}
\ No newline at end of file
diff --git a/tests/java5/generics/afterAdvice/AfterReturningRawType.aj b/tests/java5/generics/afterAdvice/AfterReturningRawType.aj
new file mode 100644
index 000000000..06fc8482b
--- /dev/null
+++ b/tests/java5/generics/afterAdvice/AfterReturningRawType.aj
@@ -0,0 +1,37 @@
+import java.util.*;
+/**
+ *   - returning(List) matches List, List<T>, List<String>
+ */
+public aspect AfterReturningRawType {
+	
+	after() returning(List l) : call(* *(..)) {
+		System.out.println("returning(List) match at " + thisJoinPointStaticPart);
+	}
+	
+	public static void main(String[] args) {
+		Generic<Double> g = new Generic<Double>();
+		g.foo(new ArrayList<Double>());
+		g.bar(new ArrayList<String>());
+		g.tada(new ArrayList());
+		g.tada(new ArrayList<String>());
+		g.tada(new ArrayList<Double>());
+	}
+	
+}
+
+class Generic<T> {
+	
+	List<T> foo(List<T> lt) {
+		return lt;
+	}
+	
+	List<String> bar(List<String> ls) {
+		return ls;
+	}
+	
+	List tada(List l) {
+		return l;
+	}
+	
+	
+}
\ No newline at end of file
diff --git a/tests/java5/generics/afterAdvice/AfterThrowing.aj b/tests/java5/generics/afterAdvice/AfterThrowing.aj
new file mode 100644
index 000000000..d04e42ea2
--- /dev/null
+++ b/tests/java5/generics/afterAdvice/AfterThrowing.aj
@@ -0,0 +1,10 @@
+public aspect AfterThrowing {
+	
+	// since a generic type may not be a subtype of throwable, this is always an
+	// error.
+	
+	after() throwing(java.util.List<String> ls) : execution(* *(..)){
+		
+	}
+	
+}
\ No newline at end of file