Rename test data folder according to the new test naming convention.

compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class AddingNullability {
+    @KotlinSignature("fun foo() : Int?")
+    public int foo() {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/AddingNullability.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class AddingNullability : Object() {
+    public open fun foo() : Int {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/AddingNullability.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.AddingNullability : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.AddingNullability
+    public open fun foo(): jet.Int
+}

compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class ExtraUpperBound {
+    @KotlinSignature("fun <A : Runnable> foo() : String where A : Cloneable")
+    public <A extends Runnable> String foo() {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class ExtraUpperBound : Object() {
+    public open fun <A : Runnable?> foo() : String? {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.ExtraUpperBound : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.ExtraUpperBound
+    public open fun </*0*/ A : java.lang.Runnable?>foo(): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class MissingUpperBound {
+    @KotlinSignature("fun <A : Runnable> foo() : String")
+    public <A extends Runnable & Cloneable> String foo() {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class MissingUpperBound : Object() {
+    public open fun <A : Runnable?> foo() : String? where A : Cloneable? {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.MissingUpperBound : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.MissingUpperBound
+    public open fun </*0*/ A : java.lang.Cloneable? & java.lang.Runnable?>foo(): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package test;
+
+import java.lang.String;
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import java.util.BitSet;
+import java.util.List;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class NotVarargReplacedWithVararg {
+    @KotlinSignature("fun foo(vararg s : String)")
+    public void foo(String s) {
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class NotVarargReplacedWithVararg : Object() {
+    public open fun foo(p0 : String?) {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.NotVarargReplacedWithVararg : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.NotVarargReplacedWithVararg
+    public open fun foo(/*0*/ p0: jet.String?): jet.Tuple0
+}

compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+import java.lang.String;
+
+public class ReturnTypeMissing {
+    @KotlinSignature("fun foo(a : String)")
+    public int foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class ReturnTypeMissing : Object() {
+    public open fun foo(p0 : String?) : Int {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.ReturnTypeMissing : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.ReturnTypeMissing
+    public open fun foo(/*0*/ p0: jet.String?): jet.Int
+}

compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class SyntaxError {
+    @KotlinSignature("fun foo(,) : Int")
+    public Integer foo() {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/SyntaxError.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class SyntaxError : Object() {
+    public open fun foo() : Int? {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/SyntaxError.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.SyntaxError : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.SyntaxError
+    public open fun foo(): jet.Int?
+}

compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java

@@ -0,0 +1,15 @@
+package test;
+
+import java.lang.String;
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import java.util.BitSet;
+import java.util.List;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class VarargReplacedWithNotVararg {
+    @KotlinSignature("fun foo(s : String)")
+    public void foo(String... s) {
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class VarargReplacedWithNotVararg : Object() {
+    public open fun foo(vararg p0 : String?) {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.VarargReplacedWithNotVararg : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.VarargReplacedWithNotVararg
+    public open fun foo(/*0*/ vararg p0: jet.String? /*jet.Array<jet.String?>*/): jet.Tuple0
+}

compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongMethodName {
+    @KotlinSignature("fun bar() : String")
+    public String foo() {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.kt

@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongMethodName : Object() {
+    public open fun foo() : String? = ""
+}

compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongMethodName : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongMethodName
+    public open fun foo(): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java

@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongReturnTypeStructure {
+    @KotlinSignature("fun foo(a : String, b : List<Map.Entry<String?, String>?>) : String<Int>?")
+    public String foo(String a, List<Map.Entry<String, String>> b) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.kt

@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongReturnTypeStructure : Object() {
+    public open fun foo(p0 : String?, p1 : List<Map.Entry<String?, String?>?>?) : String? = ""
+}

compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongReturnTypeStructure : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongReturnTypeStructure
+    public open fun foo(/*0*/ p0: jet.String?, /*1*/ p1: java.util.List<java.util.Map.Entry<jet.String?, jet.String?>?>?): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java

@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongTypeName1 {
+    @KotlinSignature("fun foo(a : String) : Unit")
+    public String foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.kt

@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongTypeName1 : Object() {
+    public open fun foo(p0 : String?) : String? = ""
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongTypeName1 : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongTypeName1
+    public open fun foo(/*0*/ p0: jet.String?): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java

@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongTypeName2 {
+    @KotlinSignature("fun foo(a : Something.String) : String")
+    public String foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.kt

@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongTypeName2 : Object() {
+    public open fun foo(p0 : String?) : String? = ""
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongTypeName2 : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongTypeName2
+    public open fun foo(/*0*/ p0: jet.String?): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java

@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongTypeName3 {
+    @KotlinSignature("fun foo(a : String) : List")
+    public String foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.kt

@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongTypeName3 : Object() {
+    public open fun foo(p0 : String?) : String? = ""
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongTypeName3 : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongTypeName3
+    public open fun foo(/*0*/ p0: jet.String?): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java

@@ -0,0 +1,14 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import java.util.BitSet;
+import java.util.List;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongTypeParameterBoundStructure1 {
+    @KotlinSignature("fun <A, B : Runnable<Int>> foo(a : A, b : List<out B>, c: List<in String?>) where B : List<Cloneable>")
+    public <A, B extends Runnable & List<Cloneable>> void foo(A a, List<? extends B> b, List<? super String> list) {
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.kt

@@ -0,0 +1,8 @@
+package test
+
+import java.util.*
+
+public open class WrongTypeParameterBoundStructure1 : Object() {
+    public open fun <erased A, erased B : Runnable?> foo(p0 : A?, p1 : List<out B>?, p2: List<in String?>?) where B : List<Cloneable?>? {
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongTypeParameterBoundStructure1 : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongTypeParameterBoundStructure1
+    public open fun </*0*/ A : jet.Any?, /*1*/ B : java.lang.Runnable? & java.util.List<java.lang.Cloneable?>?>foo(/*0*/ p0: A?, /*1*/ p1: java.util.List<out B>?, /*2*/ p2: java.util.List<in jet.String?>?): jet.Tuple0
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java

@@ -0,0 +1,14 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import java.util.BitSet;
+import java.util.List;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongTypeParameterBoundStructure2 {
+    @KotlinSignature("fun <A, B : Runnable> foo(a : A, b : List<out B>, c: List<in String?>) where B : List")
+    public <A, B extends Runnable & List<Cloneable>> void foo(A a, List<? extends B> b, List<? super String> list) {
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.kt

@@ -0,0 +1,8 @@
+package test
+
+import java.util.*
+
+public open class WrongTypeParameterBoundStructure2 : Object() {
+    public open fun <erased A, erased B : Runnable?> foo(p0 : A?, p1 : List<out B>?, p2: List<in String?>?) where B : List<Cloneable?>? {
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongTypeParameterBoundStructure2 : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongTypeParameterBoundStructure2
+    public open fun </*0*/ A : jet.Any?, /*1*/ B : java.lang.Runnable? & java.util.List<java.lang.Cloneable?>?>foo(/*0*/ p0: A?, /*1*/ p1: java.util.List<out B>?, /*2*/ p2: java.util.List<in jet.String?>?): jet.Tuple0
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java

@@ -0,0 +1,14 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import java.util.BitSet;
+import java.util.List;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongTypeParametersCount {
+    @KotlinSignature("fun <A, B, C> foo(a : A, b : List<out B>)")
+    public <A, B> void foo(A a, List<? extends B> b) {
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.kt

@@ -0,0 +1,8 @@
+package test
+
+import java.util.*
+
+public open class WrongTypeParametersCount : Object() {
+    public open fun <erased A, erased B> foo(p0 : A?, p1 : List<out B>?) {
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongTypeParametersCount : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongTypeParametersCount
+    public open fun </*0*/ A : jet.Any?, /*1*/ B : jet.Any?>foo(/*0*/ p0: A?, /*1*/ p1: java.util.List<out B>?): jet.Tuple0
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java

@@ -0,0 +1,15 @@
+package test;
+
+import java.lang.Number;
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import java.util.List;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongTypeVariance {
+    @KotlinSignature("fun copy(a : List<out Number>, b : List<Number>) : List<Number>")
+    public List<Number> copy(List<? extends Number> from, List<? super Number> to) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class WrongTypeVariance : Object() {
+    public open fun copy(p0 : List<out jet.Number?>?, p1 : List<in jet.Number?>?) : List<jet.Number?>? {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongTypeVariance : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongTypeVariance
+    public open fun copy(/*0*/ p0: java.util.List<out jet.Number?>?, /*1*/ p1: java.util.List<in jet.Number?>?): java.util.List<jet.Number?>?
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java

@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongValueParameterStructure1 {
+    @KotlinSignature("fun foo(a : String<Int?>, b : List<Map.Entry<String?, String>?>) : String")
+    public String foo(String a, List<Map.Entry<String, String>> b) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.kt

@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongValueParameterStructure1 : Object() {
+    public open fun foo(p0 : String?, p1 : List<Map.Entry<String?, String?>?>?) : String? = ""
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongValueParameterStructure1 : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongValueParameterStructure1
+    public open fun foo(/*0*/ p0: jet.String?, /*1*/ p1: java.util.List<java.util.Map.Entry<jet.String?, jet.String?>?>?): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java

@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongValueParameterStructure2 {
+    @KotlinSignature("fun foo(a : String, b : List<Map.Entry<String?>?>) : String")
+    public String foo(String a, List<Map.Entry<String, String>> b) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.kt

@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongValueParameterStructure2 : Object() {
+    public open fun foo(p0 : String?, p1 : List<Map.Entry<String?, String?>?>?) : String? = ""
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongValueParameterStructure2 : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongValueParameterStructure2
+    public open fun foo(/*0*/ p0: jet.String?, /*1*/ p1: java.util.List<java.util.Map.Entry<jet.String?, jet.String?>?>?): jet.String?
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class WrongValueParametersCount {
+    @KotlinSignature("fun foo(a : Int) : Int")
+    public Integer foo() {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.kt

@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class WrongValueParametersCount : Object() {
+    public open fun foo() : Int? {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.txt

@@ -0,0 +1,6 @@
+namespace test
+
+public open class test.WrongValueParametersCount : java.lang.Object {
+    public final /*constructor*/ fun <init>(): test.WrongValueParametersCount
+    public open fun foo(): jet.Int?
+}