/*
 * Compilers tested:
 *
 * ECJ { 3.4.1, 3.5 }
 * Javac { 1.6.0_16 }
 *
 * Javac compiles everything, but 3.4.1 and 3.5 fail differently.
 */
class GenericsTests {
       
       interface I {}
       
       interface G<T> {
              G<T> get();
       }
       
       interface A<T extends G<? extends I>> {
              T get();
       }
       
       interface Test1 {
              /*
               * All compilers allow this code.
               */
              interface B<T extends A<T> & G<? extends I>> extends G<I> {
                     B<T> get();
              }
              
              /*
               * Only 3.5 rejects this, if Q and A are transposed.
               */
              interface C<T extends G<? extends I> & A<T>> extends G<I> {
                     C<T> get();
              }
       }
       
       interface Test2 {
              
              interface S<T> {
                     void set(T t);
              }
              
              interface SS<T> extends S<S<T>> {
                     void set(S<T> s);
              }
              
              interface SI<T extends I> extends SS<T> {
                     void set(S<T> s);
              }
              
              interface GS<T extends I> extends G<T>, SI<T> {
                     GS<T> get();
              }
              
              interface F<T extends GS<? extends I>> {
                     T get();
              }
              
              /*
               * Compiles with 3.4.1 and javac, but not 3.5.
               */
              class B<T extends GS<? extends I> & F<T>> implements GS<I> {
                     T t;
                     F<T> f;
                     B(T r) { f = t = r; }
                     public B<T> get() { return new B<T>(f.get()); }
                     public void set(S<I> s) {
                            t.set(s);
                            t.set(null);
                     }
              }
              
              /*
               * Only javac compiles this class.
               */
              class C<T extends F<T> & GS<? extends I>> implements GS<I> {
                     T t;
                     F<T> f;
                     C(T r) { f = t = r; }
                     public C<T> get() { return new C<T>(f.get()); }
                     public void set(S<I> s) {
                            t.set(s);
                            t.set(null);
                     }
              }
       }
}