diff --git a/compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java b/compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java
index d815af6199b..fa42b8e090e 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java
@@ -1,8 +1,10 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public class AddingNullability {
+    @ExpectLoadError("Auto type 'jet.Int' is not-null, while type in alternative signature is nullable: 'Int?'")
     @KotlinSignature("fun foo() : Int?")
     public int foo() {
         throw new UnsupportedOperationException();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java b/compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java
index 318731787ec..bbbf35217b0 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java
@@ -1,10 +1,10 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
-
-import java.lang.String;
+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;
 }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java b/compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java
index d9155efb6a0..e059a422aac 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java
@@ -1,8 +1,10 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public class ExtraUpperBound {
+    @ExpectLoadError("Extra upper bound #1 for type parameter A")
     @KotlinSignature("fun <A : Runnable> foo() : String where A : Cloneable")
     public <A extends Runnable> String foo() {
         throw new UnsupportedOperationException();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java b/compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java
index a32c5b2a4f4..e95bdc028e9 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java
@@ -1,8 +1,10 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public class MissingUpperBound {
+    @ExpectLoadError("Upper bound #1 for type parameter A is missing")
     @KotlinSignature("fun <A : Runnable> foo() : String")
     public <A extends Runnable & Cloneable> String foo() {
         throw new UnsupportedOperationException();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/NoFieldTypeRef.java b/compiler/testData/loadJava/kotlinSignature/error/NoFieldTypeRef.java
index aa6ee47bf5e..5743c0481f5 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/NoFieldTypeRef.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/NoFieldTypeRef.java
@@ -1,10 +1,10 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
-
-import java.lang.String;
+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;
 }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java b/compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java
index 0e835fbd860..7ef352ee0fb 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java
@@ -1,30 +1,12 @@
-/*
- * 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;
+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) {
     }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java b/compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java
index 35827409244..0725f82ee1b 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java
@@ -1,26 +1,10 @@
-/*
- * 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;
+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 'jet.Int'")
     @KotlinSignature("fun foo(a : String)")
     public int foo(String a) {
         throw new UnsupportedOperationException();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java b/compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java
index 21c805204fb..d5a1e660077 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java
@@ -1,8 +1,10 @@
 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();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java b/compiler/testData/loadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java
index e632e0bf4d6..b0e0bec2711 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java
@@ -1,10 +1,10 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
-
-import java.lang.String;
+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;
 }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java b/compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java
index d0ce03358e0..98a5c5f331a 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java
@@ -1,14 +1,12 @@
 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;
+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) {
     }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldInitializer.java b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldInitializer.java
index 45f4ea8fdb1..fb4f1671e75 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldInitializer.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldInitializer.java
@@ -1,10 +1,10 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
-
-import java.lang.String;
+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;
 }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldMutability.java b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldMutability.java
index 812d623c724..7d1b4558734 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldMutability.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldMutability.java
@@ -1,13 +1,14 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
-
-import java.lang.String;
+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";
 }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldName.java b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldName.java
index ff96c6906c7..8a4f8639f9b 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldName.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldName.java
@@ -1,10 +1,10 @@
 package test;
 
 import jet.runtime.typeinfo.KotlinSignature;
-
-import java.lang.String;
+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;
 }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java b/compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java
index 52aadd8a7e3..8ef49420549 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java
@@ -1,8 +1,10 @@
 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();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java b/compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java
index 484ce0e42a0..24bdd2adf25 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java
@@ -1,10 +1,11 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 import java.util.*;
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public class WrongReturnTypeStructure {
+    @ExpectLoadError("'jet.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();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java
index af4af2283b7..c0516ad8e6c 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java
@@ -1,10 +1,11 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 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: jet.Tuple0, actual: jet.String")
     @KotlinSignature("fun foo(a : String) : Unit")
     public String foo(String a) {
         throw new UnsupportedOperationException();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java
index 6f5fc46618f..b15eaf38ed3 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java
@@ -1,10 +1,11 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 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: jet.String")
     @KotlinSignature("fun foo(a : Something.String) : String")
     public String foo(String a) {
         throw new UnsupportedOperationException();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java
index d2b90c49e53..ed711c221f7 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java
@@ -1,10 +1,11 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 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: jet.String")
     @KotlinSignature("fun foo(a : String) : List")
     public String foo(String a) {
         throw new UnsupportedOperationException();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java
index 873d96e9154..2493b5086f9 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java
@@ -1,13 +1,12 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 import java.util.*;
-import java.util.BitSet;
-import java.util.List;
 
 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<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) {
     }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java
index 7f0b443bcf5..9120dd812be 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java
@@ -1,13 +1,12 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 import java.util.*;
-import java.util.BitSet;
-import java.util.List;
 
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public class WrongTypeParameterBoundStructure2 {
+    @ExpectLoadError("'jet.List<java.lang.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<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) {
     }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java
index ade3f30faf5..64a859c06ae 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java
@@ -1,13 +1,12 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 import java.util.*;
-import java.util.BitSet;
-import java.util.List;
 
 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<out B>)")
     public <A, B> void foo(A a, List<? extends B> b) {
     }
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java
index c0d78a9e48f..4b4aca1655a 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java
@@ -1,13 +1,12 @@
 package test;
 
-import java.lang.Number;
-import java.lang.UnsupportedOperationException;
 import java.util.*;
-import java.util.List;
 
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public class WrongTypeVariance {
+    @ExpectLoadError("Variance mismatch, actual: in, in alternative signature: ")
     @KotlinSignature("fun copy(a : List<out Number>, b : List<Number>) : MutableList<Number>")
     public List<Number> copy(List<? extends Number> from, List<? super Number> to) {
         throw new UnsupportedOperationException();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java
index 89bc4c33557..7978adf6055 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java
@@ -1,10 +1,11 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 import java.util.*;
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public class WrongValueParameterStructure1 {
+    @ExpectLoadError("'jet.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();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java
index fd15f964345..40b9f5a4fcb 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java
@@ -1,10 +1,11 @@
 package test;
 
-import java.lang.UnsupportedOperationException;
 import java.util.*;
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public class WrongValueParameterStructure2 {
+    @ExpectLoadError("'jet.Map.Entry<jet.String?, jet.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();
diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java
index 3b4b3e9fd74..641ce0965b6 100644
--- a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java
+++ b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java
@@ -1,8 +1,10 @@
 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();
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java
index 7db8113091b..c239fd84fbb 100644
--- a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java
@@ -2,6 +2,7 @@ package test;
 
 import org.jetbrains.annotations.NotNull;
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public interface AddNullabilityJavaSubtype {
 
@@ -11,6 +12,7 @@ public interface AddNullabilityJavaSubtype {
     }
 
     public interface Sub extends Super {
+        @ExpectLoadError("Alternative signature has 2 syntax errors, first is at 10: Expecting '(")
         @KotlinSignature("fun String? foo()")
         String foo();
     }
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java
index 70441f2b920..0ea9be382a8 100644
--- a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java
@@ -3,6 +3,7 @@ package test;
 import org.jetbrains.annotations.NotNull;
 import java.util.List;
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public interface AddNullabilitySameGenericType1 {
 
@@ -12,6 +13,7 @@ public interface AddNullabilitySameGenericType1 {
     }
 
     public interface Sub extends Super {
+        @ExpectLoadError("Auto type 'jet.String' is not-null, while type in alternative signature is nullable: 'String?'")
         @KotlinSignature("fun foo(): MutableList<String?>")
         List<String> foo();
     }
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java
index e5faf33a7e1..dcf7c92d530 100644
--- a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java
@@ -3,6 +3,7 @@ package test;
 import org.jetbrains.annotations.NotNull;
 import java.util.List;
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public interface AddNullabilitySameGenericType2 {
 
@@ -12,6 +13,7 @@ public interface AddNullabilitySameGenericType2 {
     }
 
     public interface Sub extends Super {
+        @ExpectLoadError("Auto type 'jet.MutableList<jet.String>' is not-null, while type in alternative signature is nullable: 'MutableList<String>?'")
         @KotlinSignature("fun foo(): MutableList<String>?")
         List<String> foo();
     }
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java
index fd4f25d9cb8..06fea01d8d3 100644
--- a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java
@@ -3,6 +3,7 @@ package test;
 import org.jetbrains.annotations.NotNull;
 import java.lang.CharSequence;
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public interface AddNullabilitySameJavaType {
 
@@ -12,7 +13,8 @@ public interface AddNullabilitySameJavaType {
     }
 
     public interface Sub extends Super {
-        @KotlinSignature("fun CharSequence? foo()")
+        @ExpectLoadError("Auto type 'jet.CharSequence' is not-null, while type in alternative signature is nullable: 'CharSequence?'")
+        @KotlinSignature("fun foo(): CharSequence?")
         CharSequence foo();
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java
index c0bbc51a85d..1bc38fba2a7 100644
--- a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java
@@ -2,6 +2,7 @@ package test;
 
 import org.jetbrains.annotations.NotNull;
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 import java.util.*;
 
@@ -18,6 +19,7 @@ public interface TwoSuperclassesConflictingProjectionKinds {
     }
 
     public interface Sub extends Super1, Super2 {
+        @ExpectLoadError("Incompatible projection kinds in type arguments of super methods' return types: [CharSequence, out CharSequence]")
         public Collection<CharSequence> foo();
     }
 }
diff --git a/compiler/testData/loadJavaCustom/kotlinSignature/TwoSuperclassesInconsistentGenericTypes.java b/compiler/testData/loadJavaCustom/kotlinSignature/TwoSuperclassesInconsistentGenericTypes.java
index fb546563f87..ab9d77ac1b7 100644
--- a/compiler/testData/loadJavaCustom/kotlinSignature/TwoSuperclassesInconsistentGenericTypes.java
+++ b/compiler/testData/loadJavaCustom/kotlinSignature/TwoSuperclassesInconsistentGenericTypes.java
@@ -4,6 +4,7 @@ import org.jetbrains.annotations.NotNull;
 import java.util.List;
 
 import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
 
 public interface TwoSuperclassesInconsistentGenericTypes {
     @KotlinSignature("fun foo(): MutableList<String?>")
@@ -15,6 +16,7 @@ public interface TwoSuperclassesInconsistentGenericTypes {
     }
 
     public class Sub implements TwoSuperclassesInconsistentGenericTypes, Other {
+        @ExpectLoadError("Incompatible return types in super types: [String?, String]")
         public List<String> foo() {
             throw new UnsupportedOperationException();
         }