genericitds: now we're getting silly..

5 files changed, 132 insertions, 0 deletions

diff --git a/tests/java5/generics/itds/GenericMethodITD11.aj b/tests/java5/generics/itds/GenericMethodITD11.aj
new file mode 100644
index 000000000..df665b92c
--- /dev/null
+++ b/tests/java5/generics/itds/GenericMethodITD11.aj
@@ -0,0 +1,24 @@
+import java.util.*;
+
+class Base { 
+}
+
+public class GenericMethodITD11 {
+
+  public static void main(String[] argv) {
+    List<A> as = new ArrayList<A>();
+    new Base().crazy(as); // ok
+  }
+}
+
+interface Foo<T> {
+  public void m(T t);
+}
+
+class A implements Foo<A> {
+  public void m(A a) {}
+}
+
+aspect X {
+  <R extends Foo<? extends R>> void Base.crazy(List<R> lr) {}
+}
diff --git a/tests/java5/generics/itds/GenericMethodITD12.aj b/tests/java5/generics/itds/GenericMethodITD12.aj
new file mode 100644
index 000000000..53a45a5e2
--- /dev/null
+++ b/tests/java5/generics/itds/GenericMethodITD12.aj
@@ -0,0 +1,26 @@
+import java.util.*;
+
+class Base { 
+}
+
+public class GenericMethodITD12 {
+
+  public static void main(String[] argv) {
+    List<A> as = new ArrayList<A>();
+    new Base().crazy(as); // A doesnt implement Foo<? extends A>
+  }
+}
+
+interface Foo<T> {
+  public void m(T t);
+}
+
+class B {}
+
+class A implements Foo<B> {
+  public void m(B a) {}
+}
+
+aspect X {
+  <R extends Foo<? extends R>> void Base.crazy(List<R> lr) {}
+}
diff --git a/tests/java5/generics/itds/GenericMethodITD13.aj b/tests/java5/generics/itds/GenericMethodITD13.aj
new file mode 100644
index 000000000..a27a95f9d
--- /dev/null
+++ b/tests/java5/generics/itds/GenericMethodITD13.aj
@@ -0,0 +1,26 @@
+import java.util.*;
+
+class Base { 
+}
+
+public class GenericMethodITD13 {
+
+  public static void main(String[] argv) {
+    List<A> as = new ArrayList<A>();
+    new Base().crazy(as); // ok.  A implements Foo<C> where C extends A !!
+  }
+}
+
+interface Foo<T> {
+  public void m(T t);
+}
+
+class C extends A { }
+
+class A implements Foo<C> {
+  public void m(C a) {}
+}
+
+aspect X {
+  <R extends Foo<? extends R>> void Base.crazy(List<R> lr) {}
+}
diff --git a/tests/java5/generics/itds/GenericMethodITD14.aj b/tests/java5/generics/itds/GenericMethodITD14.aj
new file mode 100644
index 000000000..47b2aca37
--- /dev/null
+++ b/tests/java5/generics/itds/GenericMethodITD14.aj
@@ -0,0 +1,27 @@
+import java.util.*;
+
+class Base { 
+}
+
+public class GenericMethodITD14 {
+
+  public static void main(String[] argv) {
+    List<A> as = new ArrayList<A>();
+    new Base().crazy(as); // bad.  A implements Foo<C> but C is a 
+                          //       subclass of A, not a superclass
+  }
+}
+
+interface Foo<T> {
+  public void m(T t);
+}
+
+class C extends A { }
+
+class A implements Foo<C> {
+  public void m(C a) {}
+}
+
+aspect X {
+  <R extends Foo<? super R>> void Base.crazy(List<R> lr) {}
+}
diff --git a/tests/java5/generics/itds/GenericMethodITD15.aj b/tests/java5/generics/itds/GenericMethodITD15.aj
new file mode 100644
index 000000000..e711539d7
--- /dev/null
+++ b/tests/java5/generics/itds/GenericMethodITD15.aj
@@ -0,0 +1,29 @@
+import java.util.*;
+
+class Base { 
+}
+
+public class GenericMethodITD15 {
+
+  public static void main(String[] argv) {
+    List<A> as = new ArrayList<A>();
+    new Base().crazy(as); // ok. A implements Foo<C> and C is a superclass of A
+  }
+}
+
+interface Foo<T> {
+  public void m(T t);
+}
+
+
+class C {}
+
+class B extends C {}
+
+class A extends B implements Foo<C> {
+  public void m(C a) {}
+}
+
+aspect X {
+  <R extends Foo<? super R>> void Base.crazy(List<R> lr) {}
+}