Moved loadJava "general" tests to subdirectory.

2013-03-06 15:41:14 +04:00
parent 7336ec8781
commit 189b043c8d
477 changed files with 0 additions and 0 deletions
@@ -0,0 +1,10 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class ArrayType {
+    @KotlinSignature("fun foo(): Array<String>")
+    public String[] foo() {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -0,0 +1,7 @@
+package test
+
+public open class ArrayType : Object() {
+    public open fun foo(): Array<String> {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class ArrayType : java.lang.Object {
+    public constructor ArrayType()
+    public open fun foo() : jet.Array<jet.String>
+}
@@ -0,0 +1,10 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class ConstructorWithNewTypeParams<T> {
+    @KotlinSignature("fun ConstructorWithNewTypeParams(first : Any)") // TODO: first : U doesn't work
+    public <U>ConstructorWithNewTypeParams(U first) {
+    }
+}
@@ -0,0 +1,4 @@
+package test
+
+public open class ConstructorWithNewTypeParams<T>(p0 : Any) : java.lang.Object() {
+}
@@ -0,0 +1,5 @@
+package test
+
+public open class ConstructorWithNewTypeParams</*0*/ T> : java.lang.Object {
+    public constructor ConstructorWithNewTypeParams</*0*/ T>(/*0*/ p0 : jet.Any)
+}
@@ -0,0 +1,10 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class ConstructorWithParentTypeParams<T> {
+    @KotlinSignature("fun ConstructorWithParentTypeParams(first: T)")
+    public ConstructorWithParentTypeParams(T first) {
+    }
+}
@@ -0,0 +1,4 @@
+package test
+
+public open class ConstructorWithParentTypeParams<T>(p0 : T) : java.lang.Object() {
+}
@@ -0,0 +1,5 @@
+package test
+
+public open class ConstructorWithParentTypeParams</*0*/ T> : java.lang.Object {
+    public constructor ConstructorWithParentTypeParams</*0*/ T>(/*0*/ p0 : T)
+}
@@ -0,0 +1,10 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class ConstructorWithSeveralParams {
+    @KotlinSignature("fun ConstructorWithSeveralParams(integer : Int, intField : Int, collection: ArrayList<String>)")
+    public ConstructorWithSeveralParams(Integer integer, int intBasic, ArrayList<String> collection) {
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+import java.util.*
+
+public open class ConstructorWithSeveralParams(p0: Int, p1 : Int, p2 : ArrayList<String>) : java.lang.Object() {
+}
@@ -0,0 +1,5 @@
+package test
+
+public open class ConstructorWithSeveralParams : java.lang.Object {
+    public constructor ConstructorWithSeveralParams(/*0*/ p0 : jet.Int, /*1*/ p1 : jet.Int, /*2*/ p2 : java.util.ArrayList<jet.String>)
+}
@@ -0,0 +1,10 @@
+package test;
+
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class ConstructorWithoutParams {
+    @KotlinSignature("fun ConstructorWithoutParams()")
+    public ConstructorWithoutParams() {
+    }
+}
@@ -0,0 +1,4 @@
+package test
+
+public open class ConstructorWithoutParams() : java.lang.Object() {
+}
@@ -0,0 +1,5 @@
+package test
+
+public open class ConstructorWithoutParams : java.lang.Object {
+    public constructor ConstructorWithoutParams()
+}
@@ -0,0 +1,12 @@
+package test;
+
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class CustomProjectionKind {
+    @KotlinSignature("fun foo(): MutableList<out Number>")
+    public List<Number> foo() {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class CustomProjectionKind : Object() {
+    public open fun foo() : MutableList<out Number> = throw UnsupportedOperationException()
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class CustomProjectionKind : java.lang.Object {
+    public constructor CustomProjectionKind()
+    public open fun foo() : jet.MutableList<out jet.Number>
+}
@@ -0,0 +1,14 @@
+package test;
+
+import java.lang.String;
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+import jet.*;
+
+public class MethodWithFunctionTypes {
+    @KotlinSignature("fun foo(f : (String?) -> String) : (String.() -> String?)?")
+    public ExtensionFunction0<String, String> foo(Function1<String, String> f) {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class MethodWithFunctionTypes : Object() {
+    public open fun foo(p0 : (String?) -> String) : (String.() -> String?)? {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class MethodWithFunctionTypes : java.lang.Object {
+    public constructor MethodWithFunctionTypes()
+    public open fun foo(/*0*/ p0 : (jet.String?) -> jet.String) : (jet.String.() -> jet.String?)?
+}
@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class MethodWithGenerics {
+    @KotlinSignature("fun foo(a : String, b : List<Entry<String?, String>?>) : String")
+    public String foo(String a, List<Map.Entry<String, String>> b) {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class MethodWithGenerics : Object() {
+    public open fun foo(p0 : String, p1 : List<Map.Entry<String?, String>?>) : String = ""
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class MethodWithGenerics : java.lang.Object {
+    public constructor MethodWithGenerics()
+    public open fun foo(/*0*/ p0 : jet.String, /*1*/ p1 : jet.List<jet.Map.Entry<jet.String?, jet.String>?>) : jet.String
+}
@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.UnsupportedOperationException;
+import java.util.*;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class MethodWithMappedClasses {
+    @KotlinSignature("fun <T> copy(dest : MutableList<in T>, src : List<T>)")
+    public <T> void copy(List<? super T> dest, List<T> src) {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class MethodWithMappedClasses : Object() {
+    public open fun <T> copy(p0 : MutableList<in T>, p1 : List<T>) {}
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class MethodWithMappedClasses : java.lang.Object {
+    public constructor MethodWithMappedClasses()
+    public open fun </*0*/ T> copy(/*0*/ p0 : jet.MutableList<in T>, /*1*/ p1 : jet.List<T>) : Unit
+}
@@ -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 MethodWithTypeParameters {
+    @KotlinSignature("fun <A, B : Runnable> foo(a : A, b : List<B>, c: MutableList<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) {
+    }
+}
@@ -0,0 +1,8 @@
+package test
+
+import java.util.*
+
+public open class MethodWithTypeParameters : Object() {
+    public open fun <erased A, erased B : Runnable> foo(p0 : A, p1 : List<B>, p2: MutableList<in String?>) where B : List<Cloneable> {
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class MethodWithTypeParameters : java.lang.Object {
+    public constructor MethodWithTypeParameters()
+    public open fun </*0*/ A, /*1*/ B> foo(/*0*/ p0 : A, /*1*/ p1 : jet.List<B>, /*2*/ p2 : jet.MutableList<in jet.String?>) : Unit where B : java.lang.Runnable, B : jet.List<java.lang.Cloneable>
+}
@@ -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 MethodWithVararg {
+    @KotlinSignature("fun foo(vararg s : String)")
+    public void foo(String... s) {
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class MethodWithVararg : Object() {
+    public open fun foo(vararg p0 : String) {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class MethodWithVararg : java.lang.Object {
+    public constructor MethodWithVararg()
+    public open fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : Unit
+}
@@ -0,0 +1,17 @@
+package test;
+
+import java.lang.String;
+import java.util.ArrayList;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class PropertyArrayTypes<T> {
+    @KotlinSignature("var arrayOfArrays : Array<Array<String>>")
+    public String[][] arrayOfArrays;
+
+    @KotlinSignature("var array : Array<String>")
+    public String[] array;
+
+    @KotlinSignature("var genericArray : Array<T>")
+    public T[] genericArray;
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class PropertyArrayTypes<T>() : java.lang.Object() {
+  public var arrayOfArrays : Array<Array<String>> = null!!
+  public var array : Array<String> = null!!
+  public var genericArray : Array<T> = null!!
+}
@@ -0,0 +1,8 @@
+package test
+
+public open class PropertyArrayTypes</*0*/ T> : java.lang.Object {
+    public constructor PropertyArrayTypes</*0*/ T>()
+    public final var array : jet.Array<jet.String>
+    public final var arrayOfArrays : jet.Array<jet.Array<jet.String>>
+    public final var genericArray : jet.Array<T>
+}
@@ -0,0 +1,20 @@
+package test;
+
+import java.lang.String;
+import java.util.ArrayList;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class PropertyComplexTypes<T> {
+    @KotlinSignature("var genericType : T")
+    public T genericType;
+
+    @KotlinSignature("var listDefinedGeneric : ArrayList<String>")
+    public ArrayList<String> listDefinedGeneric;
+
+    @KotlinSignature("var listGeneric : ArrayList<T>")
+    public ArrayList<T> listGeneric;
+
+    @KotlinSignature("var listOfGenericList : ArrayList<ArrayList<T>>")
+    public ArrayList<ArrayList<T>> listOfGenericList;
+}
@@ -0,0 +1,10 @@
+package test
+
+import java.util.*
+
+public open class PropertyComplexTypes<T>() : java.lang.Object() {
+  public var genericType : T = null!!
+  public var listDefinedGeneric : ArrayList<String> = null!!
+  public var listGeneric : ArrayList<T> = null!!
+  public var listOfGenericList : ArrayList<ArrayList<T>> = null!!
+}
@@ -0,0 +1,9 @@
+package test
+
+public open class PropertyComplexTypes</*0*/ T> : java.lang.Object {
+    public constructor PropertyComplexTypes</*0*/ T>()
+    public final var genericType : T
+    public final var listDefinedGeneric : java.util.ArrayList<jet.String>
+    public final var listGeneric : java.util.ArrayList<T>
+    public final var listOfGenericList : java.util.ArrayList<java.util.ArrayList<T>>
+}
@@ -0,0 +1,12 @@
+package test;
+
+import java.lang.String;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public class PropertySimpleType {
+    @KotlinSignature("var fieldOne : String")
+    public String fieldOne;
+
+    @KotlinSignature("var fieldTwo : String?")
+    public String fieldTwo;
+}
@@ -0,0 +1,8 @@
+package test
+
+import java.util.*
+
+public open class PropertySimpleType : java.lang.Object() {
+  public var fieldOne : String = ""
+  public var fieldTwo : String? = null
+}
@@ -0,0 +1,7 @@
+package test
+
+public open class PropertySimpleType : java.lang.Object {
+    public constructor PropertySimpleType()
+    public final var fieldOne : jet.String
+    public final var fieldTwo : jet.String?
+}
@@ -0,0 +1,13 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public final class StarProjection {
+    @KotlinSignature("fun foo(): MyClass<*>")
+    public final MyClass<?> foo() {
+        throw new UnsupportedOperationException();
+    }
+
+    public interface MyClass<T extends CharSequence> {
+    }
+}
@@ -0,0 +1,7 @@
+package test
+
+public final class StarProjection: Object() {
+    public final fun foo(): MyClass<*> = throw UnsupportedOperationException()
+
+    public trait MyClass<T: CharSequence?>: Object
+}
@@ -0,0 +1,9 @@
+package test
+
+public final class StarProjection : java.lang.Object {
+    public constructor StarProjection()
+    public final fun foo() : test.StarProjection.MyClass<out jet.CharSequence?>
+    
+    public trait MyClass</*0*/ T : jet.CharSequence?> : java.lang.Object {
+    }
+}
@@ -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 'jet.Int' is not-null, while type in alternative signature is nullable: 'Int?'")
+    @KotlinSignature("fun foo() : Int?")
+    public int foo() {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class AddingNullability : Object() {
+    public open fun foo() : Int {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class AddingNullability : java.lang.Object {
+    public constructor AddingNullability()
+    public open fun foo() : jet.Int
+}
@@ -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 jet.List")
+    @KotlinSignature("fun foo(list: List<in Number>)")
+    public void foo(List<Number> list) {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -0,0 +1,7 @@
+package test
+
+public open class ConflictingProjectionKind : Object() {
+    public open fun foo(p0: List<Number>?) {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class ConflictingProjectionKind : java.lang.Object {
+    public constructor ConflictingProjectionKind()
+    public open fun foo(/*0*/ p0 : jet.List<jet.Number>?) : Unit
+}
@@ -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;
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class ExplicitFieldGettersAndSetters : Object() {
+    public var foo : String? = ""
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class ExplicitFieldGettersAndSetters : java.lang.Object {
+    public constructor ExplicitFieldGettersAndSetters()
+    public final var foo : jet.String?
+}
@@ -0,0 +1,12 @@
+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();
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class ExtraUpperBound : Object() {
+    public open fun <A : Runnable?> foo() : String? {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class ExtraUpperBound : java.lang.Object {
+    public constructor ExtraUpperBound()
+    public open fun </*0*/ A : java.lang.Runnable?> foo() : jet.String?
+}
@@ -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 #1 for type parameter A is missing")
+    @KotlinSignature("fun <A : Runnable> foo() : String")
+    public <A extends Runnable & Cloneable> String foo() {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -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()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class MissingUpperBound : java.lang.Object {
+    public constructor MissingUpperBound()
+    public open fun </*0*/ A> foo() : jet.String? where A : java.lang.Runnable?, A : java.lang.Cloneable?
+}
@@ -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;
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class NoFieldTypeRef : Object() {
+    public var foo : String? = ""
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class NoFieldTypeRef : java.lang.Object {
+    public constructor NoFieldTypeRef()
+    public final var foo : jet.String?
+}
@@ -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) {
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class NotVarargReplacedWithVararg : Object() {
+    public open fun foo(p0 : String?) {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class NotVarargReplacedWithVararg : java.lang.Object {
+    public constructor NotVarargReplacedWithVararg()
+    public open fun foo(/*0*/ p0 : jet.String?) : Unit
+}
@@ -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();
+    }
+}
@@ -0,0 +1,7 @@
+package test
+
+public open class RedundantProjectionKind : Object() {
+    public open fun foo(p0: List<Number>) {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class RedundantProjectionKind : java.lang.Object {
+    public constructor RedundantProjectionKind()
+    public open fun foo(/*0*/ p0 : jet.List<jet.Number>) : Unit
+}
@@ -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 'jet.Int'")
+    @KotlinSignature("fun foo(a : String)")
+    public int foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class ReturnTypeMissing : Object() {
+    public open fun foo(p0 : String?) : Int {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class ReturnTypeMissing : java.lang.Object {
+    public constructor ReturnTypeMissing()
+    public open fun foo(/*0*/ p0 : jet.String?) : jet.Int
+}
@@ -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();
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class SyntaxError : Object() {
+    public open fun foo() : Int? {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class SyntaxError : java.lang.Object {
+    public constructor SyntaxError()
+    public open fun foo() : jet.Int?
+}
@@ -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;
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class SyntaxErrorInFieldAnnotation : Object() {
+    public var foo : String? = ""
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class SyntaxErrorInFieldAnnotation : java.lang.Object {
+    public constructor SyntaxErrorInFieldAnnotation()
+    public final var foo : jet.String?
+}
@@ -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) {
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class VarargReplacedWithNotVararg : Object() {
+    public open fun foo(vararg p0 : String?) {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class VarargReplacedWithNotVararg : java.lang.Object {
+    public constructor VarargReplacedWithNotVararg()
+    public open fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : Unit
+}
@@ -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;
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongFieldInitializer : Object() {
+    public var foo : String? = ""
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class WrongFieldInitializer : java.lang.Object {
+    public constructor WrongFieldInitializer()
+    public final var foo : jet.String?
+}
@@ -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";
+}
@@ -0,0 +1,8 @@
+package test
+
+import java.util.*
+
+public open class WrongFieldMutability : Object() {
+    public var fooNotFinal : String? = ""
+    public val fooFinal : String? = ""
+}
@@ -0,0 +1,7 @@
+package test
+
+public open class WrongFieldMutability : java.lang.Object {
+    public constructor WrongFieldMutability()
+    public final val fooFinal : jet.String?
+    public final var fooNotFinal : jet.String?
+}
@@ -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;
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongFieldName : Object() {
+    public var foo : String? = ""
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class WrongFieldName : java.lang.Object {
+    public constructor WrongFieldName()
+    public final var foo : jet.String?
+}
@@ -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();
+    }
+}
@@ -0,0 +1,7 @@
+package test
+
+import java.util.*
+
+public open class WrongMethodName : Object() {
+    public open fun foo() : String? = ""
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class WrongMethodName : java.lang.Object {
+    public constructor WrongMethodName()
+    public open fun foo() : jet.String?
+}
@@ -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();
+    }
+}
@@ -0,0 +1,9 @@
+package test
+
+import java.util.*
+
+public open class WrongProjectionKind : Object() {
+    public open fun copy(p0 : Array<out Number>?, p1 : Array<out Number>?) : MutableList<Number>? {
+        throw UnsupportedOperationException()
+    }
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class WrongProjectionKind : java.lang.Object {
+    public constructor WrongProjectionKind()
+    public open fun copy(/*0*/ p0 : jet.Array<out jet.Number>?, /*1*/ p1 : jet.Array<out jet.Number>?) : jet.MutableList<jet.Number>?
+}
@@ -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("'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();
+    }
+}
@@ -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? = ""
+}
@@ -0,0 +1,6 @@
+package test
+
+public open class WrongReturnTypeStructure : java.lang.Object {
+    public constructor WrongReturnTypeStructure()
+    public open fun foo(/*0*/ p0 : jet.String?, /*1*/ p1 : jet.List<jet.Map.Entry<jet.String, jet.String>>?) : jet.String?
+}
@@ -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: jet.Tuple0, actual: jet.String")
+    @KotlinSignature("fun foo(a : String) : Unit")
+    public String foo(String a) {
+        throw new UnsupportedOperationException();
+    }
+}
--- a/Show More
+++ b/Show More