Moved sourceJava cases to generated test.

compiler/testData/loadJava/sourceJava/ErrorTypes.java

@@ -0,0 +1,17 @@
+package test;
+
+import java.util.List;
+
+public interface ErrorTypes {
+    interface Super {
+        void errorTypeInParameter(List<T[]> list);
+
+        T returnErrorType();
+    }
+
+    interface Sub extends Super {
+        void errorTypeInParameter(List<T[]> list);
+
+        T  returnErrorType();
+    }
+}

compiler/testData/loadJava/sourceJava/ErrorTypes.txt

@@ -0,0 +1,15 @@
+package test
+
+public trait ErrorTypes : java.lang.Object {
+    
+    public trait Sub : test.ErrorTypes.Super {
+        public abstract fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : Unit
+        public abstract override /*1*/ /*fake_override*/ fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : Unit
+        public abstract override /*1*/ fun returnErrorType() : [ERROR : Unresolved java class: T]
+    }
+    
+    public trait Super : java.lang.Object {
+        public abstract fun errorTypeInParameter(/*0*/ list : jet.List<jet.Array<[ERROR : Unresolved java class: T]>?>?) : Unit
+        public abstract fun returnErrorType() : [ERROR : Unresolved java class: T]
+    }
+}

compiler/testData/loadJava/sourceJava/ReturnInnerSubclassOfSupersInner.java

@@ -0,0 +1,22 @@
+package test;
+
+//Note: this test could be written in simple load java test, but KT-3128 prevents from writing Kotlin counterpart for it
+//See the same test data in compiledJava test data.
+//Test data is duplicated because Java PSI used to have some differences when loading parallel generic hierarchies from cls and source code.
+public interface ReturnInnerSubclassOfSupersInner {
+    class Super<A> {
+        class Inner {
+            Super<A> get() {
+                throw new UnsupportedOperationException();
+            }
+        }
+    }
+
+    class Sub<B> extends Super<B> {
+        class Inner extends Super<B>.Inner {
+            Sub<B> get() {
+                throw new UnsupportedOperationException();
+            }
+        }
+    }
+}

compiler/testData/loadJava/sourceJava/ReturnInnerSubclassOfSupersInner.txt

@@ -0,0 +1,22 @@
+package test
+
+public trait ReturnInnerSubclassOfSupersInner : java.lang.Object {
+    
+    public open class Sub</*0*/ B> : test.ReturnInnerSubclassOfSupersInner.Super<B> {
+        public constructor Sub</*0*/ B>()
+        
+        public/*package*/ open inner class Inner : test.ReturnInnerSubclassOfSupersInner.Super.Inner {
+            public/*package*/ constructor Inner()
+            public/*package*/ open override /*1*/ fun get() : test.ReturnInnerSubclassOfSupersInner.Sub<B>?
+        }
+    }
+    
+    public open class Super</*0*/ A> : java.lang.Object {
+        public constructor Super</*0*/ A>()
+        
+        public/*package*/ open inner class Inner : java.lang.Object {
+            public/*package*/ constructor Inner()
+            public/*package*/ open fun get() : test.ReturnInnerSubclassOfSupersInner.Super<A>?
+        }
+    }
+}

compiler/testData/loadJava/sourceJava/ReturnNotSubtype.java

@@ -0,0 +1,32 @@
+package test;
+
+import java.util.List;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface ReturnNotSubtype {
+    interface Super<T> {
+        T t();
+
+        void _void();
+
+        String string1();
+        String string2();
+
+        Class<? extends CharSequence> klass();
+
+        T[] array();
+    }
+
+    interface Sub extends Super<Boolean> {
+        Void t();
+
+        boolean _void();
+
+        void string1();
+        List<Boolean> string2();
+
+        Class<?> klass();
+
+        Void[] array();
+    }
+}

compiler/testData/loadJava/sourceJava/ReturnNotSubtype.txt

@@ -0,0 +1,22 @@
+package test
+
+public trait ReturnNotSubtype : java.lang.Object {
+    
+    public trait Sub : test.ReturnNotSubtype.Super<jet.Boolean> {
+        public abstract override /*1*/ fun _void() : jet.Boolean
+        public abstract override /*1*/ fun array() : jet.Array<java.lang.Void>?
+        public abstract override /*1*/ fun klass() : java.lang.Class<out jet.Any?>?
+        public abstract override /*1*/ fun string1() : Unit
+        public abstract override /*1*/ fun string2() : jet.MutableList<jet.Boolean>?
+        public abstract override /*1*/ fun t() : java.lang.Void?
+    }
+    
+    public trait Super</*0*/ T> : java.lang.Object {
+        public abstract fun _void() : Unit
+        public abstract fun array() : jet.Array<T>?
+        public abstract fun klass() : java.lang.Class<out jet.CharSequence?>?
+        public abstract fun string1() : jet.String?
+        public abstract fun string2() : jet.String?
+        public abstract fun t() : T?
+    }
+}

compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.java

@@ -0,0 +1,16 @@
+package test;
+
+public interface WrongNumberOfGenericParameters {
+
+    interface Zero {}
+    interface One<T> {}
+
+    Zero<String> z();
+
+    One o0();
+    One<String, String> o2();
+
+    // This does not produce the expected result, because IDEA thinks Two<X> is a raw type
+    interface Two<P, Q> {}
+    Two<String> t1();
+}

compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.txt

@@ -0,0 +1,17 @@
+package test
+
+public trait WrongNumberOfGenericParameters : java.lang.Object {
+    public abstract fun o0() : test.WrongNumberOfGenericParameters.One<out jet.Any?>?
+    public abstract fun o2() : test.WrongNumberOfGenericParameters.One<[ERROR : T]>?
+    public abstract fun t1() : test.WrongNumberOfGenericParameters.Two<out jet.Any?, out jet.Any?>?
+    public abstract fun z() : test.WrongNumberOfGenericParameters.Zero?
+    
+    public trait One</*0*/ T> : java.lang.Object {
+    }
+    
+    public trait Two</*0*/ P, /*1*/ Q> : java.lang.Object {
+    }
+    
+    public trait Zero : java.lang.Object {
+    }
+}