genericitds: more combinations

diff --git a/tests/java5/generics/itds/GenericCtorITD1.aj b/tests/java5/generics/itds/GenericCtorITD1.aj
new file mode 100644 (file)
index 0000000..9d06505
--- /dev/null
+++ b/tests/java5/generics/itds/GenericCtorITD1.aj
@@ -0,0 +1,18 @@
+import java.util.*;
+
+class Base { }
+
+public class GenericCtorITD1 {
+  public static void main(String[] argv) { 
+    // Use the generic ctor
+    List<String> ls = new ArrayList<String>();
+    Base bs = new Base(ls); // ok
+    List<Integer> li = new ArrayList<Integer>();
+    Base bi = new Base(li); // ok
+  }
+}
+
+
+aspect X {
+  <T> Base.new(List<T> elements) { }
+}

diff --git a/tests/java5/generics/itds/GenericCtorITD2.aj b/tests/java5/generics/itds/GenericCtorITD2.aj
new file mode 100644 (file)
index 0000000..9fc96e6
--- /dev/null
+++ b/tests/java5/generics/itds/GenericCtorITD2.aj
@@ -0,0 +1,22 @@
+import java.util.*;
+
+class Base { 
+// <T> Base(List<T> one,List<? extends T> two) { }
+}
+
+public class GenericCtorITD2 {
+  public static void main(String[] argv) {
+    List<A> as = new ArrayList<A>();
+    List<B> bs = new ArrayList<B>();
+    new Base(as,bs); // ok
+  }
+
+  class A {}
+  class B extends A {}
+}
+
+
+aspect X {
+  // wildcards, argh!
+  <T> Base.new(List<T> one,List<? extends T> two) { }
+}

diff --git a/tests/java5/generics/itds/GenericCtorITD3.aj b/tests/java5/generics/itds/GenericCtorITD3.aj
new file mode 100644 (file)
index 0000000..03b5587
--- /dev/null
+++ b/tests/java5/generics/itds/GenericCtorITD3.aj
@@ -0,0 +1,44 @@
+import java.util.*;
+
+class MathUtils { } 
+
+class Sorter    { 
+  public static List l;
+//  <T> Sorter(List<T> elements,Comparator<? super T> comparator) { 
+//      Collections.sort(elements,comparator);
+//      l = elements;
+//  }
+}
+
+public class GenericCtorITD3 {
+  public static void main(String[] argv) {
+    List<Simple> ls = new ArrayList<Simple>();
+    ls.add(new Simple(2));
+    ls.add(new Simple(1));
+    ls.add(new Simple(5));
+    ls.add(new Simple(3));
+    new Sorter(ls,new SimpleComparator());
+    System.err.println(Sorter.l.get(0));
+    System.err.println(Sorter.l.get(1));
+    System.err.println(Sorter.l.get(2));
+    System.err.println(Sorter.l.get(3));
+  }
+
+  static class Simple {
+    int n;
+    Simple(int i) { n=i;}
+    public String toString() { return new String(""+n); }
+  }
+
+  static class SimpleComparator implements Comparator<Simple> {
+    public int compare(Simple a, Simple b) { return a.n-b.n;}
+  }
+}
+
+
+aspect X {
+  <T> Sorter.new(List<T> elements,Comparator<? super T> comparator) { 
+       Collections.sort(elements,comparator);
+       l = elements;
+  }
+}