import java.util.ArrayList;
import java.util.List;

class Test {
  List<String> queue = new ArrayList<>();
  ArrayList l = new ArrayList<>(8);
}

class HMCopy<K, V> {
  private Entry[] table;

  class Entry<K, V> {
    Entry(int h, K k, V v, Entry<K, V> n) {
    }
  }

  void addEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K, V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
  }
}

class DD {
    P1<P<String>> l = new L<String>() {
        @Override
        void f() {
        }
    };

    P1<P<String>> l1 = new L<>();

    P1<P<String>> foo() {
        return new L<>();
    }

    String s = "";
}

class L<K> extends P1<P<K>> {
    void f() {
    }
}

class P1<P1T> extends P<P1T> {
}

class P<PT> {
}


class Test1 {
  void bar() {
    foo<error descr="'foo(F<F<java.lang.String>>)' in 'Test1' cannot be applied to '(FF<java.lang.Object>)'">(new FF<>())</error>;
  }

  void foo(F<F<String>> p) {}
}

class FF<X> extends F<X>{}
class F<T> {}

class MyTest {
     static class Foo<X> {
        Foo(X x) {}
     }

     static interface Base<Y> {}
     static class A extends Exception implements Base<String> {}
     static class B extends Exception implements Base<Integer> {}

     void m() throws B {
         try {
             if (true) {
                 throw new A();
             }
             else {
                 throw new B();
             }
         } catch (A ex) {
             Foo<? extends Base<String>> foo1 = new Foo<>(ex);  // ok
             <error descr="Incompatible types. Found: 'MyTest.Foo<MyTest.A>', required: 'MyTest.Foo<MyTest.Base<java.lang.String>>'">Foo<Base<String>> foo2 = new Foo<>(ex);</error>  // should be error
         }
     }
}

class NonParameterized {
  void foo() {
    new NonParameterized<<error descr="Diamond operator is not applicable for non-parameterized types"></error>>();
  }
}


interface I<T> {
  T m();
}

class FI1 {
  I<? extends String> i1 = new I<<error descr="Cannot use ''<>'' with anonymous inner classes"></error>>() {
    @Override
    public String m() {
      return null;
    }
  };

  I<?> i2 = new I<<error descr="Cannot use ''<>'' with anonymous inner classes"></error>>() {
    @Override
    public Object m() {
      return null;
    }
  };
}

class Super<X,Y> {
    private Super(Integer i, Y y, X x) {}
    public Super(Number n, X x, Y y) {}
}

class TestMySuper {
    Super<String,Integer> ssi1 = new Super<>(1, "", 2);
}

class TestLocal<X> {
    class Member { }
    static class Nested {}

    void test() {
        class Local {}

        Member m = new Member<<error descr="Diamond operator is not applicable for non-parameterized types"></error>>();
        Nested n = new Nested<<error descr="Diamond operator is not applicable for non-parameterized types"></error>>();
        Local l = new Local<<error descr="Diamond operator is not applicable for non-parameterized types"></error>>();
    }
}

class QualifiedTest {
  java.util.Map<String, String> s = new java.util.HashMap<>();
}


class TZ {

}

class ParenthTest<T extends TZ> {
    public ParenthTest(T x) {

    }

    public T z = null;

    public int a() {
        ParenthTest<T> x = (new ParenthTest<>(null)); //red code is here
        return 1;
    }
}

class TestWildcardInference {
  interface A<T> {
  }

  class B<V> implements A<V> {
    B(C<V> v) {
    }
  }

  class C<E> {}

  class U {
    void foo() {
      C<? extends Number> x = null;
      A<? extends Number> y = new B<>(x);
    }
  }
}

class PredefinedErrorsOverRaw<T> {
  <U> PredefinedErrorsOverRaw(T t) {
  }

  void test() {
    PredefinedErrorsOverRaw mc = new <Boolean>PredefinedErrorsOverRaw<<error descr="Cannot use diamonds with explicit type parameters for constructor"></error>>("");
  }
}

class Outer {
    class Inner<T> {}
}
class Outer1 {}

class Outer2<K> {
    class Inner2<T> {}
}

class Another {
    public static void main(String[] args) {
        Outer o = new Outer();
        Outer.Inner<String> i = o.new Inner<>();
        Outer.Inner<String> i1 = m().new Inner<>();
        Outer.Inner<String> i2 = m1().new Inner<>();

        Outer.Inner<String> i3 = m2().new <error descr="Cannot resolve symbol 'Inner'">Inner</error><>();

        System.out.println(i);

        <error descr="Incompatible types. Found: 'Outer2.Inner2<java.lang.String>', required: 'Outer2<java.lang.Integer>.Inner2<java.lang.String>'">Outer2<Integer>.Inner2<String> i5 = new Outer2<>().new Inner2<>();</error>
    }

  static Outer m() {return null;}
  static <T extends Outer> T m1() {return null;}
  static <T> T m2() {return null;}

}

class TypeParamsExtendsList {

        {
               new TypeWithGeneric<>();
        }

        private static class A {}

        private static class TypeWithGeneric<T extends A> extends ArrayList<T> {

        }
}