From a0e7fbf879f45831be1ead2dcf5ff74c642d0d2b Mon Sep 17 00:00:00 2001 From: acolyer Date: Tue, 9 Aug 2005 12:56:00 +0000 Subject: [PATCH] new tests cases for args with generics and generic methods in general --- .../generics/pointcuts/ArgsListOfSomething.aj | 51 +++++++++++++++ .../pointcuts/ArgsListOfSomethingExtends.aj | 31 +++++++++ .../pointcuts/ArgsListOfSomethingSuper.aj | 36 ++++++++++ .../generics/pointcuts/ArgsParameterized.aj | 65 +++++++++++++++++++ .../ArgsParameterizedWithWildcards.aj | 40 ++++++++++++ .../generics/pointcuts/GenericMethods.aj | 42 ++++++++++++ .../GenericWildcardsInSignatureMatching.aj | 39 +++++++++++ tests/java5/generics/pointcuts/RawArgs.aj | 37 +++++++++++ 8 files changed, 341 insertions(+) create mode 100644 tests/java5/generics/pointcuts/ArgsListOfSomething.aj create mode 100644 tests/java5/generics/pointcuts/ArgsListOfSomethingExtends.aj create mode 100644 tests/java5/generics/pointcuts/ArgsListOfSomethingSuper.aj create mode 100644 tests/java5/generics/pointcuts/ArgsParameterized.aj create mode 100644 tests/java5/generics/pointcuts/ArgsParameterizedWithWildcards.aj create mode 100644 tests/java5/generics/pointcuts/GenericMethods.aj create mode 100644 tests/java5/generics/pointcuts/GenericWildcardsInSignatureMatching.aj create mode 100644 tests/java5/generics/pointcuts/RawArgs.aj diff --git a/tests/java5/generics/pointcuts/ArgsListOfSomething.aj b/tests/java5/generics/pointcuts/ArgsListOfSomething.aj new file mode 100644 index 000000000..d7fc9bad1 --- /dev/null +++ b/tests/java5/generics/pointcuts/ArgsListOfSomething.aj @@ -0,0 +1,51 @@ +import java.util.*; + +public aspect ArgsListOfSomething { + + // args(List) matches List, List, List, ... + + void rawList(List l) {} + void listOfString(List ls) {} + void listOfSomething(List ls) {} + void listOfSomethingExtends(List ln) {} + void listOfSomethingSuper(List ln) {} + + // try a couple of nested variations too + void mapit(Map,List>> m) {} + void setOf(HashSet sd) {} + + public static void main(String[] args) { + ArgsListOfSomething a = ArgsListOfSomething.aspectOf(); + a.rawList(null); + a.listOfString(null); + a.listOfSomething(null); + a.listOfSomethingExtends(null); + a.listOfSomethingSuper(null); + a.mapit(null); + a.setOf(null); + } + + before() : execution(* *(..)) && args(List) { + System.out.println("List matches " + thisJoinPointStaticPart); + } + + before() : execution(* *(..)) && args(Map) { + System.out.println("wild map matches " + thisJoinPointStaticPart); + } + @org.aspectj.lang.annotation.SuppressAjWarnings + before() : execution(* *(..)) && args(HashMap,List>>) { + System.out.println("nested wild map does not match " + thisJoinPointStaticPart); + } + + before() : execution(* *(..)) && args(Map,List>>) { + System.out.println("exact wild map matches " + thisJoinPointStaticPart); + } + + before() : execution(* *(..)) && args(Set) { + System.out.println("super type exact matches " + thisJoinPointStaticPart); + } + + before() : execution(* *(..)) && args(Set) { + System.out.println("super wild type matches " + thisJoinPointStaticPart); + } +} \ No newline at end of file diff --git a/tests/java5/generics/pointcuts/ArgsListOfSomethingExtends.aj b/tests/java5/generics/pointcuts/ArgsListOfSomethingExtends.aj new file mode 100644 index 000000000..7db1c5977 --- /dev/null +++ b/tests/java5/generics/pointcuts/ArgsListOfSomethingExtends.aj @@ -0,0 +1,31 @@ +import java.util.*; + +public aspect ArgsListOfSomethingExtends { + + // args(List, List, not List + // matches List, List with unchecked warning + + void rawList(List l) {} + void listOfString(List ls) {} + void listOfNumber(List ln) {} + void listOfDouble(List ld) {} + void listOfSomething(List ls) {} + void listOfSomethingExtends(List ln) {} + void listOfSomethingSuper(List ln) {} + + public static void main(String[] args) { + ArgsListOfSomethingExtends a = ArgsListOfSomethingExtends.aspectOf(); + a.rawList(null); + a.listOfString(null); + a.listOfNumber(null); + a.listOfDouble(null); + a.listOfSomething(null); + a.listOfSomethingExtends(null); + a.listOfSomethingSuper(null); + } + + before() : execution(* *(..)) && args(List) { + System.out.println("List matches " + thisJoinPointStaticPart); + } + +} \ No newline at end of file diff --git a/tests/java5/generics/pointcuts/ArgsListOfSomethingSuper.aj b/tests/java5/generics/pointcuts/ArgsListOfSomethingSuper.aj new file mode 100644 index 000000000..54bb5d7e7 --- /dev/null +++ b/tests/java5/generics/pointcuts/ArgsListOfSomethingSuper.aj @@ -0,0 +1,36 @@ +import java.util.*; + +public aspect ArgsListOfSomethingSuper { + + /* + * - args(List) matches List, List + * does not match List + * matches List, List with unchecked warning + * matches List + * matches List with unchecked warning + */ + + void rawList(List l) {} + void listOfObject(List ls) {} + void listOfNumber(List ln) {} + void listOfDouble(List ld) {} + void listOfSomething(List ls) {} + void listOfSomethingSuper(List ln) {} + void listOfSomethingExtendsNumber(List ln) {} + + public static void main(String[] args) { + ArgsListOfSomethingSuper a = ArgsListOfSomethingSuper.aspectOf(); + a.rawList(null); + a.listOfObject(null); + a.listOfNumber(null); + a.listOfDouble(null); + a.listOfSomething(null); + a.listOfSomethingSuper(null); + a.listOfSomethingExtendsNumber(null); + } + + before() : execution(* *(..)) && args(List) { + System.out.println("List matches " + thisJoinPointStaticPart); + } + +} \ No newline at end of file diff --git a/tests/java5/generics/pointcuts/ArgsParameterized.aj b/tests/java5/generics/pointcuts/ArgsParameterized.aj new file mode 100644 index 000000000..afa6eef4b --- /dev/null +++ b/tests/java5/generics/pointcuts/ArgsParameterized.aj @@ -0,0 +1,65 @@ +import java.util.*; +/** + * - args(List) matches List but not List + * - args(List) matches List with unchecked warning + * - args(List) matches List with unchecked warning + * - args(List) matches List with unchecked warning + * - args(List) matches List (String is final) + */ +public aspect ArgsParameterized { + + public static void main(String[] args) { + List ls = new ArrayList(); +// ls.add("one"); +// ls.add("two"); +// ls.add("three"); + + Generic g = new Generic(); + g.foo(ls); + g.bar(ls); + g.tada(ls); + g.afar(new ArrayList()); + g.something(ls); + + MustBeString mbs = new MustBeString(); + mbs.listit(ls); + } + + before(List ls) : call(* *(..)) && args(ls) { + System.out.println("args(List matched at " + thisJoinPointStaticPart); + ls.add("four"); + String s = ls.get(0); + } + +} + +class Generic { + + void foo(List lt) { + ; + } + + void bar(List ls) { + ; + } + + void tada(List l) { + ; + } + + void afar(List ln) { + ; + } + + void something(List ls) { + ; + } +} + +class MustBeString { + + void listit(List lt) { + ; + } + +} \ No newline at end of file diff --git a/tests/java5/generics/pointcuts/ArgsParameterizedWithWildcards.aj b/tests/java5/generics/pointcuts/ArgsParameterizedWithWildcards.aj new file mode 100644 index 000000000..dcbd9a90c --- /dev/null +++ b/tests/java5/generics/pointcuts/ArgsParameterizedWithWildcards.aj @@ -0,0 +1,40 @@ +import java.util.*; + +public aspect ArgsParameterizedWithWildcards { + + /* + * - args(List) matches List, List, List with unchecked warning + * matches List, List ok (since Double is final) + */ + + before() : execution(* *(..)) && args(List) { + System.out.println("List matched at " + thisJoinPointStaticPart); + } + + public static void main(String[] args) { + C c = new C(); + List ld = new ArrayList(); + c.rawList(ld); + c.listOfSomething(ld); + c.listOfSomeNumber(ld); + c.listOfDouble(ld); + c.listOfSomeDouble(ld); + c.listOfString(new ArrayList()); + } +} + +class C { + + void rawList(List l) {} + + void listOfSomething(List ls) {} + + void listOfSomeNumber(List ln) {} + + void listOfDouble(List ld) {} + + void listOfSomeDouble(List ld) {} + + void listOfString(List ls) {} + +} \ No newline at end of file diff --git a/tests/java5/generics/pointcuts/GenericMethods.aj b/tests/java5/generics/pointcuts/GenericMethods.aj new file mode 100644 index 000000000..c126461a9 --- /dev/null +++ b/tests/java5/generics/pointcuts/GenericMethods.aj @@ -0,0 +1,42 @@ +import java.util.*; + +public aspect GenericMethods { + + declare warning : execution(Object whoAmI(Object)) + : "static generic method match"; + + declare warning : withincode(Number myFavourite(List)) + : "instance generic method match"; + + // should we have an XLint to explain why the pointcut below does not match? + declare warning : execution(* myFavourite(List)) + : "no match because erasure is List"; + +} + +class PlainClassWithGenericMethods { + + public static T whoAmI(T t) { + return t; + } + + public S myFavourite(List ls) { + return ls.get(0); + } + + +} + +class GenericClassWithGenericMethods { + + N n; + + public static T whoAmI(T t) { + return t; + } + + public S myFavourite(List ls) { + return ls.get(0); + } + +} \ No newline at end of file diff --git a/tests/java5/generics/pointcuts/GenericWildcardsInSignatureMatching.aj b/tests/java5/generics/pointcuts/GenericWildcardsInSignatureMatching.aj new file mode 100644 index 000000000..57618914f --- /dev/null +++ b/tests/java5/generics/pointcuts/GenericWildcardsInSignatureMatching.aj @@ -0,0 +1,39 @@ +import java.util.*; import java.io.*; + +public class GenericWildcardsInSignatureMatching { + + List aList = new ArrayList(); + + void foo(Map>> map) { + ; + } + + List findOne(List ld) { + return ld; + } + + void anyOrder(List l) {} + +} + + +aspect WildcardMatcher { + + declare warning : set(List *) : "set of a list"; + + declare warning : execution(* foo(Map>>)) + : "exact nested wildcard match"; + + declare warning : execution(* foo(Map>)) + : "wildcard nested wildcard match"; + + declare warning : execution(List findOne(List)) + : "super"; + + declare warning : execution(* anyOrder(List)) + : "super wild match"; + + declare warning : execution(* anyOrder(List)) + : "no match - signature is different"; + +} \ No newline at end of file diff --git a/tests/java5/generics/pointcuts/RawArgs.aj b/tests/java5/generics/pointcuts/RawArgs.aj new file mode 100644 index 000000000..6a126db87 --- /dev/null +++ b/tests/java5/generics/pointcuts/RawArgs.aj @@ -0,0 +1,37 @@ +import java.util.*; +/** + * - args(List) matches List, List, List + */ +public aspect RawArgs { + + before() : args(List) && call(* *(..)) { + System.out.println("args(List) match at " + thisJoinPointStaticPart); + } + + public static void main(String[] args) { + Generic g = new Generic(); + g.foo(new ArrayList()); + g.bar(new ArrayList()); + g.tada(new ArrayList()); + g.tada(new ArrayList()); + g.tada(new ArrayList()); + } + +} + +class Generic { + + void foo(List lt) { + ; + } + + void bar(List ls) { + ; + } + + void tada(List l) { + ; + } + + +} \ No newline at end of file -- 2.39.5