Merge boxWithStdlib testData into box, delete BoxWithStdlib test

2016-03-07 13:36:14 +03:00
parent 22bfc9786a
commit 06a67e6602
535 changed files with 3520 additions and 3871 deletions
@@ -0,0 +1,18 @@
+// WITH_REFLECT
+
+interface A {
+    fun foo(): Collection<Any>
+}
+
+abstract class B : A {
+    override fun foo(): Collection<String> = null!!
+}
+
+fun box(): String {
+    val clazz = B::class.java
+    if (clazz.declaredMethods.first().genericReturnType.toString() != "java.util.Collection<java.lang.String>") return "fail 1"
+
+    if (clazz.methods.filter { it.name == "foo" }.size != 1) return "fail 2"
+
+    return "OK"
+}
@@ -0,0 +1,44 @@
+// FILE: J.java
+
+public class J {
+
+    public static int test1() {
+        A<String, B<String>> x = new X<String, B<String>>("O", new B<String>("K"));
+        return A.DefaultImpls.test1(x, 1, 1.0);
+    }
+
+
+    public static A<String, B<String>> test2(){
+        X<String, B<String>> x = new X<String, B<String>>("O", new B<String>("K"));
+        return A.DefaultImpls.test2(x, 1);
+    }
+}
+
+// FILE: K.kt
+
+class B<T>(val value: T)
+
+interface A<T, Y : B<T>> {
+
+    fun <T, L> test1(p: T, z: L): T {
+        return p
+    }
+
+    fun <L> test2(p: L): A<T, Y> {
+        return this
+    }
+}
+
+
+class X<T, Y : B<T>>(val p1: T, val p2: Y) : A<T, Y> {
+
+}
+
+fun box(): String {
+    val test1 = J.test1()
+    if (test1 != 1) return "fail 1: $test1 != 1"
+
+    val test2: X<String, B<String>> = J.test2() as X<String, B<String>>
+
+    return test2.p1 + test2.p2.value
+}
@@ -0,0 +1,33 @@
+import java.util.Date
+
+fun assertGenericSuper(expected: String, function: Any?) {
+    val clazz = (function as java.lang.Object).getClass()!!
+    val genericSuper = clazz.getGenericInterfaces()[0]!!
+    if ("$genericSuper" != expected)
+        throw AssertionError("Fail, expected: $expected, actual: $genericSuper")
+}
+
+
+val unitFun = { }
+val intFun = { 42 }
+val stringParamFun = { x: String -> }
+val listFun = { l: List<String> -> l }
+val mutableListFun = fun (l: MutableList<Double>): MutableList<Int> = null!!
+val funWithIn = fun (x: Comparable<String>) {}
+
+val extensionFun = fun Any.() {}
+val extensionWithArgFun = fun Long.(x: Any): Date = Date()
+
+fun box(): String {
+    assertGenericSuper("kotlin.jvm.functions.Function0<kotlin.Unit>", unitFun)
+    assertGenericSuper("kotlin.jvm.functions.Function0<java.lang.Integer>", intFun)
+    assertGenericSuper("kotlin.jvm.functions.Function1<java.lang.String, kotlin.Unit>", stringParamFun)
+    assertGenericSuper("kotlin.jvm.functions.Function1<java.util.List<? extends java.lang.String>, java.util.List<? extends java.lang.String>>", listFun)
+    assertGenericSuper("kotlin.jvm.functions.Function1<java.util.List<java.lang.Double>, java.util.List<java.lang.Integer>>", mutableListFun)
+    assertGenericSuper("kotlin.jvm.functions.Function1<java.lang.Comparable<? super java.lang.String>, kotlin.Unit>", funWithIn)
+
+    assertGenericSuper("kotlin.jvm.functions.Function1<java.lang.Object, kotlin.Unit>", extensionFun)
+    assertGenericSuper("kotlin.jvm.functions.Function2<java.lang.Long, java.lang.Object, java.util.Date>", extensionWithArgFun)
+
+    return "OK"
+}
@@ -0,0 +1,83 @@
+// WITH_REFLECT
+//test for KT-3722 Write correct generic type information for generated fields
+import kotlin.properties.Delegates
+
+class Z<T> {
+
+}
+
+class TParam {
+
+}
+
+class Zout<out T> {
+
+}
+
+class Zin<in T> {
+
+}
+
+
+class Test<T>(val constructorProperty: T) {
+
+    val classField1 : Z<T>? = null
+
+    val classField2 : Z<String>? = null
+
+    val classField3 : Zout<String>? = null
+
+    val classField4 : Zin<TParam>? = null
+
+    val delegateLazy: Z<TParam>? by lazy {Z<TParam>()}
+
+    val delegateNotNull: Z<TParam>? by Delegates.notNull()
+
+
+}
+
+fun box(): String {
+    val clz = Test::class.java
+
+    val constructorProperty = clz.getDeclaredField("constructorProperty");
+
+    if (constructorProperty.getGenericType().toString() != "T")
+        return "fail0: " + constructorProperty.getGenericType();
+
+
+    val classField = clz.getDeclaredField("classField1");
+
+    if (classField.getGenericType().toString() != "Z<T>")
+        return "fail1:" + classField.getGenericType();
+
+
+    val classField2 = clz.getDeclaredField("classField2");
+
+    if (classField2.getGenericType().toString() != "Z<java.lang.String>")
+        return "fail2:" + classField2.getGenericType();
+
+
+    val classField3 = clz.getDeclaredField("classField3");
+
+    if (classField3.getGenericType().toString() != "Zout<java.lang.String>")
+        return "fail3:" + classField3.getGenericType();
+
+
+    val classField4 = clz.getDeclaredField("classField4");
+
+    if (classField4.getGenericType().toString() != "Zin<TParam>")
+        return "fail4:" + classField4.getGenericType();
+
+    val classField5 = clz.getDeclaredField("delegateLazy\$delegate");
+
+    if (classField5.getGenericType().toString() != "kotlin.Lazy<Z<TParam>>")
+        return "fail5:" + classField5.getGenericType();
+
+    val classField6 = clz.getDeclaredField("delegateNotNull\$delegate");
+
+    if (classField6.getGenericType().toString() != "kotlin.properties.ReadWriteProperty<java.lang.Object, Z<TParam>>")
+        return "fail6:" + classField6.getGenericType();
+
+
+    return "OK"
+}
@@ -0,0 +1,62 @@
+// WITH_REFLECT
+
+class Z<T> {}
+
+class TParam {}
+
+class Zout<out T> {}
+
+class Zin<in T> {}
+
+class Params(val methodIndex: Int, val paramClass: Class<*>, val expectedReturnType: String, val expecedParamType: String)
+
+class Test<T, X, in Y>() {
+
+    fun test1(p: T): T? = null
+
+    fun test2(p: Z<T>): Z<T>? = null
+
+    fun test3(p: Z<String>): Z<String>? = null
+
+    fun test4(p: X):  Zout<out String>? = null
+
+    fun test5(p: Y): Zin<in TParam>? = null
+}
+
+fun box(): String {
+    val clz = Test::class.java
+
+    val params = listOf(
+            Params(1, Any::class.java, "T", "T"),
+            Params(2, Z::class.java, "Z<T>", "Z<T>"),
+            Params(3, Z::class.java, "Z<java.lang.String>", "Z<java.lang.String>"),
+            Params(4, Any::class.java, "Zout<java.lang.String>", "X"),
+            Params(5, Any::class.java, "Zin<TParam>", "Y")
+    )
+
+
+    var result: String = ""
+    for(p in params) {
+        val fail = test(clz, p.methodIndex, p.paramClass, p.expectedReturnType, p.expecedParamType)
+        if (fail != "OK") {
+            result += fail + "\n";
+        }
+    }
+
+    return if (result.isEmpty()) "OK" else result;
+
+}
+
+fun test(clazz: Class<*>, methodIndex: Int, paramClass: Class<*>, expectedReturn : String, expectedParam : String): String {
+    val method = clazz.getDeclaredMethod("test$methodIndex", paramClass)!!;
+
+    if (method.getGenericReturnType().toString() != expectedReturn)
+        return "fail$methodIndex: " + method.getGenericReturnType();
+
+    val test1Param = method.getGenericParameterTypes()!![0];
+
+    if (test1Param.toString() != expectedParam)
+        return "fail${methodIndex}_param: " + test1Param;
+
+    return "OK"
+}
@@ -0,0 +1,25 @@
+// WITH_REFLECT
+
+class B<M>
+
+interface A<T, Y : B<T>> {
+
+    fun <T, L> p(p: T): T {
+        return p
+    }
+
+    val <T> T.z : T?
+        get() = null
+}
+
+
+fun box(): String {
+    val defaultImpls = Class.forName("A\$DefaultImpls")
+    val declaredMethod = defaultImpls.getDeclaredMethod("p", A::class.java, Any::class.java)
+    if (declaredMethod.toGenericString() != "public static <T_I1,Y,T,L> T A\$DefaultImpls.p(A<T_I1, Y>,T)") return "fail 1: ${declaredMethod.toGenericString()}"
+
+    val declaredProperty = defaultImpls.getDeclaredMethod("getZ", A::class.java, Any::class.java)
+    if (declaredProperty.toGenericString() != "public static <T_I1,Y,T> T A\$DefaultImpls.getZ(A<T_I1, Y>,T)") return "fail 2: ${declaredProperty.toGenericString()}"
+
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// WITH_REFLECT
+
+package test
+
+class G<T>(val s: T) {
+
+}
+
+public interface ErrorsJvmTrait {
+    companion object {
+        public val param : G<String> = G("STRING")
+    }
+}
+
+public class ErrorsJvmClass {
+    companion object {
+        @JvmField public val param : G<String> = G("STRING")
+    }
+}
+
+fun box(): String {
+    val genericTypeInClassObject = ErrorsJvmTrait.javaClass.getDeclaredField("param").getGenericType()
+    if (genericTypeInClassObject.toString() != "test.G<java.lang.String>") return "fail1: $genericTypeInClassObject"
+
+    val genericTypeInClass = ErrorsJvmClass::class.java.getField("param").getGenericType()
+    if (genericTypeInClass.toString() != "test.G<java.lang.String>") return "fail1: genericTypeInClass"
+    return "OK"
+}
@@ -0,0 +1,28 @@
+// WITH_REFLECT
+
+package test
+
+open class B
+
+class A {
+
+    companion object {
+        @JvmStatic
+        fun <T: B> a(s: T) : T {
+            return s
+        }
+    }
+}
+
+fun box(): String {
+    val method = A::class.java.getDeclaredMethod("a", B::class.java)
+    val genericParameterTypes = method.getGenericParameterTypes()
+
+    if (genericParameterTypes.size != 1) return "Wrong number of generic parameters"
+
+    if (genericParameterTypes[0].toString() != "T") return "Wrong parameter type ${genericParameterTypes[0].toString()}"
+
+    if (method.getGenericReturnType().toString() != "T") return "Wrong return type ${method.getGenericReturnType()}"
+
+    return "OK"
+}