Test data split between compiledJava tests and compiledKotlin tests

Basically, this commit splits test data from the from java-txt-kt to two pairs java-txt and kt-txt.
This commit leads to some duplication in test data.
This is temporary: in the platform types branch the test data for LoadJava tests will be changed dramatically, so duplication will go away

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

@@ -0,0 +1,12 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class AddingNullability {
+    @ExpectLoadError("Auto type 'kotlin.Int' is not-null, while type in alternative signature is nullable: 'Int?'")
+    @KotlinSignature("fun foo() : Int?")
+    public int foo() {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class AddingNullability {
+    public constructor AddingNullability()
+    public open fun foo(): kotlin.Int
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/ConflictingProjectionKind.java

@@ -0,0 +1,15 @@
+package test;
+
+import java.lang.Number;
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class ConflictingProjectionKind {
+    @ExpectLoadError("Projection kind 'in' is conflicting with variance of kotlin.List")
+    @KotlinSignature("fun foo(list: List<in Number>)")
+    public void foo(List<Number> list) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/ConflictingProjectionKind.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class ConflictingProjectionKind {
+    public constructor ConflictingProjectionKind()
+    public open fun foo(/*0*/ p0: kotlin.List<kotlin.Number>?): kotlin.Unit
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class ExplicitFieldGettersAndSetters {
+    @ExpectLoadError("Field annotation for shouldn't have getters and setters")
+    @KotlinSignature("var foo: String get() { return \"hello\" }")
+    public String foo;
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class ExplicitFieldGettersAndSetters {
+    public constructor ExplicitFieldGettersAndSetters()
+    public final var foo: kotlin.String?
+}

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

@@ -0,0 +1,12 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class ExtraUpperBound {
+    @ExpectLoadError("Upper bound number mismatch for A. Expected 1, but found 2")
+    @KotlinSignature("fun <A : Runnable> foo() : String where A : Cloneable")
+    public <A extends Runnable> String foo() {
+        throw new UnsupportedOperationException();
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class MissingUpperBound {
+    @ExpectLoadError("Upper bound number mismatch for A. Expected 2, but found 1")
+    @KotlinSignature("fun <A : Runnable> foo() : String")
+    public <A extends Runnable & Cloneable> String foo() {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class MissingUpperBound {
+    public constructor MissingUpperBound()
+    public open fun </*0*/ A : java.lang.Runnable?> foo(): kotlin.String? where A : kotlin.Cloneable?
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/NoFieldTypeRef.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class NoFieldTypeRef {
+    @ExpectLoadError("Field annotation for shouldn't have type reference")
+    @KotlinSignature("var foo")
+    public String foo;
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/NoFieldTypeRef.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class NoFieldTypeRef {
+    public constructor NoFieldTypeRef()
+    public final var foo: kotlin.String?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class NotVarargReplacedWithVararg {
+    @ExpectLoadError("Parameter in method signature is not vararg, but in alternative signature it is vararg")
+    @KotlinSignature("fun foo(vararg s : String)")
+    public void foo(String s) {
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class NotVarargReplacedWithVararg {
+    public constructor NotVarargReplacedWithVararg()
+    public open fun foo(/*0*/ p0: kotlin.String?): kotlin.Unit
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/RedundantProjectionKind.java

@@ -0,0 +1,14 @@
+package test;
+
+import java.lang.Number;
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class RedundantProjectionKind {
+    @KotlinSignature("fun foo(list: List<out Number>)")
+    public void foo(List<Number> list) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/RedundantProjectionKind.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class RedundantProjectionKind {
+    public constructor RedundantProjectionKind()
+    public open fun foo(/*0*/ list: kotlin.List<kotlin.Number>): kotlin.Unit
+}

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

@@ -0,0 +1,12 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class ReturnTypeMissing {
+    @ExpectLoadError("Return type in alternative signature is missing, while in real signature it is 'kotlin.Int'")
+    @KotlinSignature("fun foo(a : String)")
+    public int foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class ReturnTypeMissing {
+    public constructor ReturnTypeMissing()
+    public open fun foo(/*0*/ p0: kotlin.String?): kotlin.Int
+}

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

@@ -0,0 +1,12 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class SyntaxError {
+    @ExpectLoadError("Alternative signature has 2 syntax errors, first is at 8: Expecting a parameter declaration")
+    @KotlinSignature("fun foo(,) : Int")
+    public Integer foo() {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class SyntaxError {
+    public constructor SyntaxError()
+    public open fun foo(): kotlin.Int?
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class SyntaxErrorInFieldAnnotation {
+    @ExpectLoadError("Alternative signature has syntax error at 10: Type expected")
+    @KotlinSignature("var foo : ")
+    public String foo;
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class SyntaxErrorInFieldAnnotation {
+    public constructor SyntaxErrorInFieldAnnotation()
+    public final var foo: kotlin.String?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class VarargReplacedWithNotVararg {
+    @ExpectLoadError("Parameter in method signature is vararg, but in alternative signature it is not")
+    @KotlinSignature("fun foo(s : String)")
+    public void foo(String... s) {
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class VarargReplacedWithNotVararg {
+    public constructor VarargReplacedWithNotVararg()
+    public open fun foo(/*0*/ vararg p0: kotlin.String? /*kotlin.Array<kotlin.String?>*/): kotlin.Unit
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongFieldInitializer.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongFieldInitializer {
+    @ExpectLoadError("Default value is not expected in annotation for field")
+    @KotlinSignature("var foo : String = \"Test\"")
+    public String foo;
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongFieldInitializer.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongFieldInitializer {
+    public constructor WrongFieldInitializer()
+    public final var foo: kotlin.String?
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongFieldMutability.java

@@ -0,0 +1,14 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongFieldMutability {
+    @ExpectLoadError("Wrong mutability in annotation for field")
+    @KotlinSignature("val fooNotFinal : String")
+    public String fooNotFinal;
+
+    @ExpectLoadError("Wrong mutability in annotation for field")
+    @KotlinSignature("var fooFinal : String")
+    public final String fooFinal = "Test";
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongFieldMutability.txt

@@ -0,0 +1,7 @@
+package test
+
+public open class WrongFieldMutability {
+    public constructor WrongFieldMutability()
+    public final val fooFinal: kotlin.String? = "Test"
+    public final var fooNotFinal: kotlin.String?
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongFieldName.java

@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongFieldName {
+    @ExpectLoadError("Field name mismatch, original: foo, alternative: bar")
+    @KotlinSignature("var bar: String")
+    public String foo;
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongFieldName.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongFieldName {
+    public constructor WrongFieldName()
+    public final var foo: kotlin.String?
+}

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

@@ -0,0 +1,12 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongMethodName {
+    @ExpectLoadError("Function names mismatch, original: foo, alternative: bar")
+    @KotlinSignature("fun bar() : String")
+    public String foo() {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongMethodName {
+    public constructor WrongMethodName()
+    public open fun foo(): kotlin.String?
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongProjectionKind.java

@@ -0,0 +1,15 @@
+package test;
+
+import java.lang.Number;
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongProjectionKind {
+    @ExpectLoadError("Projection kind mismatch, actual: out, in alternative signature: ")
+    @KotlinSignature("fun copy(a : Array<out Number>, b : Array<Number>) : MutableList<Number>")
+    public List<Number> copy(Number[] from, Number[] to) {
+        throw new UnsupportedOperationException();
+    }
+}

compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongProjectionKind.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongProjectionKind {
+    public constructor WrongProjectionKind()
+    public open fun copy(/*0*/ p0: kotlin.Array<out kotlin.Number>?, /*1*/ p1: kotlin.Array<out kotlin.Number>?): kotlin.MutableList<kotlin.Number>?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongReturnTypeStructure {
+    @ExpectLoadError("'kotlin.String?' type in method signature has 0 type arguments, while 'String<Int>' in alternative signature has 1 of them")
+    @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/compiledJava/kotlinSignature/error/WrongReturnTypeStructure.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongReturnTypeStructure {
+    public constructor WrongReturnTypeStructure()
+    public open fun foo(/*0*/ p0: kotlin.String?, /*1*/ p1: kotlin.List<kotlin.Map.Entry<kotlin.String, kotlin.String>>?): kotlin.String?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongTypeName1 {
+    @ExpectLoadError("Alternative signature type mismatch, expected: Unit, actual: kotlin.String")
+    @KotlinSignature("fun foo(a : String) : Unit")
+    public String foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongTypeName1 {
+    public constructor WrongTypeName1()
+    public open fun foo(/*0*/ p0: kotlin.String?): kotlin.String?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongTypeName2 {
+    @ExpectLoadError("Alternative signature type mismatch, expected: Something.String, actual: kotlin.String")
+    @KotlinSignature("fun foo(a : Something.String) : String")
+    public String foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongTypeName2 {
+    public constructor WrongTypeName2()
+    public open fun foo(/*0*/ p0: kotlin.String?): kotlin.String?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongTypeName3 {
+    @ExpectLoadError("Alternative signature type mismatch, expected: List, actual: kotlin.String")
+    @KotlinSignature("fun foo(a : String) : List")
+    public String foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongTypeName3 {
+    public constructor WrongTypeName3()
+    public open fun foo(/*0*/ p0: kotlin.String?): kotlin.String?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongTypeParameterBoundStructure1 {
+    @ExpectLoadError("'java.lang.Runnable?' type in method signature has 0 type arguments, while 'Runnable<Int>' in alternative signature has 1 of them")
+    @KotlinSignature("fun <A, B : Runnable<Int>> foo(a : A, b : List<B>) where B : List<Cloneable>")
+    public <A, B extends Runnable & List<Cloneable>> void foo(A a, List<? extends B> b) {
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongTypeParameterBoundStructure1 {
+    public constructor WrongTypeParameterBoundStructure1()
+    public open fun </*0*/ A, /*1*/ B : java.lang.Runnable?> foo(/*0*/ p0: A?, /*1*/ p1: kotlin.List<B>?): kotlin.Unit where B : kotlin.List<kotlin.Cloneable>?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongTypeParameterBoundStructure2 {
+    @ExpectLoadError("'kotlin.List<kotlin.Cloneable>?' type in method signature has 1 type arguments, while 'List' in alternative signature has 0 of them")
+    @KotlinSignature("fun <A, B : Runnable> foo(a : A, b : List<B>) where B : List")
+    public <A, B extends Runnable & List<Cloneable>> void foo(A a, List<? extends B> b) {
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongTypeParameterBoundStructure2 {
+    public constructor WrongTypeParameterBoundStructure2()
+    public open fun </*0*/ A, /*1*/ B : java.lang.Runnable?> foo(/*0*/ p0: A?, /*1*/ p1: kotlin.List<B>?): kotlin.Unit where B : kotlin.List<kotlin.Cloneable>?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongTypeParametersCount {
+    @ExpectLoadError("Method signature has 2 type parameters, but alternative signature has 3")
+    @KotlinSignature("fun <A, B, C> foo(a : A, b : List<B>)")
+    public <A, B> void foo(A a, List<? extends B> b) {
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongTypeParametersCount {
+    public constructor WrongTypeParametersCount()
+    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0: A?, /*1*/ p1: kotlin.List<B>?): kotlin.Unit
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongValueParameterStructure1 {
+    @ExpectLoadError("'kotlin.String?' type in method signature has 0 type arguments, while 'String<Int?>' in alternative signature has 1 of them")
+    @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/compiledJava/kotlinSignature/error/WrongValueParameterStructure1.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongValueParameterStructure1 {
+    public constructor WrongValueParameterStructure1()
+    public open fun foo(/*0*/ p0: kotlin.String?, /*1*/ p1: kotlin.List<kotlin.Map.Entry<kotlin.String, kotlin.String>>?): kotlin.String?
+}

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

@@ -0,0 +1,13 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongValueParameterStructure2 {
+    @ExpectLoadError("'kotlin.Map.Entry<kotlin.String, kotlin.String>' type in method signature has 2 type arguments, while 'Map.Entry<String?>' in alternative signature has 1 of them")
+    @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/compiledJava/kotlinSignature/error/WrongValueParameterStructure2.txt

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongValueParameterStructure2 {
+    public constructor WrongValueParameterStructure2()
+    public open fun foo(/*0*/ p0: kotlin.String?, /*1*/ p1: kotlin.List<kotlin.Map.Entry<kotlin.String, kotlin.String>>?): kotlin.String?
+}

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

@@ -0,0 +1,12 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public class WrongValueParametersCount {
+    @ExpectLoadError("Method signature has 0 value parameters, but alternative signature has 1")
+    @KotlinSignature("fun foo(a : Int) : Int")
+    public Integer foo() {
+        throw new UnsupportedOperationException();
+    }
+}

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

@@ -0,0 +1,6 @@
+package test
+
+public open class WrongValueParametersCount {
+    public constructor WrongValueParametersCount()
+    public open fun foo(): kotlin.Int?
+}